diff options
| author | Damien Zammit <damien@zamaudio.com> | 2014-07-01 09:47:05 +1000 |
|---|---|---|
| committer | Damien Zammit <damien@zamaudio.com> | 2014-07-01 09:47:05 +1000 |
| commit | 3ae993b40dd0629ae257c0bb34e07a7f22cd96ed (patch) | |
| tree | 53858b7dc901608a90adf81f738ad7b44e9c78ab | |
| parent | 0a3d9fc62236cfdb16993009262e8a31c82ac5a1 (diff) | |
| parent | d9f19c1ea41be270ca51049f65298317971e62b1 (diff) | |
Merge branch 'falkTX-master'
110 files changed, 19050 insertions, 2127 deletions
@@ -11,3 +11,11 @@ bin/*-dssi/ bin/*.lv2/ libs/lv2_ttl_generator + +bin/ZaMultiComp +bin/ZaMultiCompX2 +bin/ZamComp +bin/ZamCompX2 +bin/ZamEQ2 +bin/ZamSynth +bin/ZamTube diff --git a/.plugins.kdev4 b/.plugins.kdev4 new file mode 100644 index 0000000..c638d82 --- /dev/null +++ b/.plugins.kdev4 @@ -0,0 +1,9 @@ +[Project] +Manager=KDevGenericManager +Name=ZamAudio Plugins + +[Filters] +Excludes=*/.*,*/*~,*/*.a + +[Project] +VersionControlSupport=kdevgit diff --git a/Makefile.mk b/Makefile.mk index 524ad21..37e9426 100644 --- a/Makefile.mk +++ b/Makefile.mk @@ -4,20 +4,9 @@ # Created by falkTX # -AR ?= ar -RM ?= rm -f CC ?= gcc CXX ?= g++ -# No heavy optimisations -OPTIMIZATIONS ?= -O2 -ffast-math - -# Heavy optimisations -#OPTIMIZATIONS ?= -O2 -ffast-math -mtune=generic -msse -msse2 -mfpmath=sse - -# Raspberry Pi -#OPTIMIZATIONS ?= -O2 -ffast-math -march=armv6 -mfpu=vfp -mfloat-abi=hard - # -------------------------------------------------------------- # Fallback to Linux if no other OS defined @@ -32,9 +21,11 @@ endif # -------------------------------------------------------------- # Common build and link flags - BASE_FLAGS = -Wall -Wextra -pipe -BASE_OPTS = $(OPTIMIZATIONS) -fdata-sections -ffunction-sections +BASE_OPTS = -O2 -ffast-math -fdata-sections -ffunction-sections +ifneq ($(NOOPT),true) +BASE_OPTS += -mtune=generic -msse -msse2 -mfpmath=sse +endif LINK_OPTS = -fdata-sections -ffunction-sections -Wl,-O1 -Wl,--as-needed -Wl,--gc-sections -Wl,--strip-all ifeq ($(MACOS),true) @@ -43,8 +34,11 @@ LINK_OPTS = -fdata-sections -ffunction-sections -Wl,-dead_strip -Wl,-dead_strip endif ifeq ($(RASPPI),true) -# Raspberry-Pi optimization flags -BASE_OPTS = $(OPTIMIZATIONS) +# Raspberry-Pi flags +BASE_OPTS = -O2 -ffast-math +ifneq ($(NOOPT),true) +BASE_OPTS += -march=armv6 -mfpu=vfp -mfloat-abi=hard +endif LINK_OPTS = -Wl,-O1 -Wl,--as-needed -Wl,--strip-all endif @@ -75,6 +69,9 @@ endif # Check for required libs ifeq ($(LINUX),true) +ifneq ($(shell pkg-config --exists jack && echo true),true) +$(error JACK missing, cannot continue) +endif ifneq ($(shell pkg-config --exists gl && echo true),true) $(error OpenGL missing, cannot continue) endif @@ -83,6 +80,10 @@ $(error X11 missing, cannot continue) endif endif +ifneq ($(shell pkg-config --exists liblo && echo true),true) +$(error liblo missing, cannot continue) +endif + # -------------------------------------------------------------- # Set libs stuff diff --git a/libs/dgl/App.hpp b/libs/dgl/App.hpp index 6eb8f2a..1afac9f 100644 --- a/libs/dgl/App.hpp +++ b/libs/dgl/App.hpp @@ -25,37 +25,58 @@ class Window; // ----------------------------------------------------------------------- +/** + Base DGL Application class. + + One application instance is required for creating a window. + There's no single/global application instance in DGL, and multiple + windows can share the same app instance. + + In standalone mode an application will automatically quit its + event-loop when all its windows are closed. + */ class App { public: - class IdleCallback - { - public: - virtual ~IdleCallback() {} - virtual void idleCallback() = 0; - }; - + /** + Constructor. + */ App(); + + /** + Destructor. + */ ~App(); + /** + Idle function. + This calls all this app Windows' idle functions and idle callbacks. + */ void idle(); + + /** + Run the application event-loop until all Windows are closed. + @idle() is called at regular intervals. + */ void exec(); + + /** + Quit the application. + This stops the event-loop and closes all Windows. + */ void quit(); - bool isQuiting() const; - void addIdleCallback(IdleCallback* const callback); - void removeIdleCallback(IdleCallback* const callback); + /** + Check if the application is about to quit. + Returning true means there's no event-loop running at the moment. + */ + bool isQuiting() const noexcept; private: struct PrivateData; PrivateData* const pData; friend class Window; - void _addWindow(Window* const window); - void _removeWindow(Window* const window); - void _oneShown(); - void _oneHidden(); - DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(App) }; diff --git a/libs/dgl/Base.hpp b/libs/dgl/Base.hpp index 14e142f..0d62d72 100644 --- a/libs/dgl/Base.hpp +++ b/libs/dgl/Base.hpp @@ -18,10 +18,11 @@ #define DGL_BASE_HPP_INCLUDED #include "../distrho/extra/d_leakdetector.hpp" +#include "../distrho/extra/d_scopedpointer.hpp" // ----------------------------------------------------------------------- +// Define namespace -/* Define namespace */ #ifndef DGL_NAMESPACE # define DGL_NAMESPACE DGL #endif @@ -30,14 +31,59 @@ #define END_NAMESPACE_DGL } #define USE_NAMESPACE_DGL using namespace DGL_NAMESPACE; -/* GL includes */ +#ifdef DISTRHO_OS_WINDOWS +// ----------------------------------------------------------------------- +// Fix OpenGL includes for Windows, based on glfw code + +#ifndef APIENTRY +# define APIENTRY __stdcall +#endif // APIENTRY + +/* We need WINGDIAPI defined */ +#ifndef WINGDIAPI +# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__POCC__) +# define WINGDIAPI __declspec(dllimport) +# elif defined(__LCC__) +# define WINGDIAPI __stdcall +# else +# define WINGDIAPI extern +# endif +# define DGL_WINGDIAPI_DEFINED +#endif // WINGDIAPI + +/* Some <GL/glu.h> files also need CALLBACK defined */ +#ifndef CALLBACK +# if defined(_MSC_VER) +# if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS) +# define CALLBACK __stdcall +# else +# define CALLBACK +# endif +# else +# define CALLBACK __stdcall +# endif +# define DGL_CALLBACK_DEFINED +#endif // CALLBACK + +/* Most GL/glu.h variants on Windows need wchar_t */ +#include <cstddef> + +#endif // DISTRHO_OS_WINDOWS + +// ----------------------------------------------------------------------- +// OpenGL includes + #ifdef DISTRHO_OS_MAC -# include <OpenGL/gl.h> +# include "OpenGL/gl.h" #else -# include <GL/gl.h> +# define GL_GLEXT_PROTOTYPES +# include "GL/gl.h" +# include "GL/glext.h" #endif -/* missing GL defines */ +// ----------------------------------------------------------------------- +// Missing OpenGL defines + #if defined(GL_BGR_EXT) && ! defined(GL_BGR) # define GL_BGR GL_BGR_EXT #endif @@ -50,12 +96,29 @@ # define GL_CLAMP_TO_BORDER 0x812D #endif +#ifdef DISTRHO_OS_WINDOWS +// ----------------------------------------------------------------------- +// Fix OpenGL includes for Windows, based on glfw code + +#ifdef DGL_WINGDIAPI_DEFINED +# undef WINGDIAPI +# undef DGL_WINGDIAPI_DEFINED +#endif + +#ifdef DGL_CALLBACK_DEFINED +# undef CALLBACK +# undef DGL_CALLBACK_DEFINED +#endif + +#endif // DISTRHO_OS_WINDOWS + START_NAMESPACE_DGL // ----------------------------------------------------------------------- +// Base DGL enums -/* - * Convenience symbols for ASCII control characters. +/** + Convenience symbols for ASCII control characters. */ enum Char { CHAR_BACKSPACE = 0x08, @@ -63,8 +126,8 @@ enum Char { CHAR_DELETE = 0x7F }; -/* - * Special (non-Unicode) keyboard keys. +/** + Special (non-Unicode) keyboard keys. */ enum Key { KEY_F1 = 1, @@ -94,8 +157,8 @@ enum Key { KEY_SUPER }; -/* - * Keyboard modifier flags. +/** + Keyboard modifier flags. */ enum Modifier { MODIFIER_SHIFT = 1 << 0, /**< Shift key */ @@ -105,6 +168,19 @@ enum Modifier { }; // ----------------------------------------------------------------------- +// Base DGL classes + +/** + Idle callback. + */ +class IdleCallback +{ +public: + virtual ~IdleCallback() {} + virtual void idleCallback() = 0; +}; + +// ----------------------------------------------------------------------- END_NAMESPACE_DGL diff --git a/libs/dgl/CairoWidget.hpp b/libs/dgl/CairoWidget.hpp index 1d68544..9ebfe8f 100644 --- a/libs/dgl/CairoWidget.hpp +++ b/libs/dgl/CairoWidget.hpp @@ -102,7 +102,7 @@ private: cairoDisplay(fContext); // get cairo surface data (RGB24) - unsigned char* const surfaceData = cairo_image_surface_get_data(fSurface); + uchar* const surfaceData = cairo_image_surface_get_data(fSurface); // enable GL texture glEnable(GL_TEXTURE_RECTANGLE_ARB); diff --git a/libs/dgl/Geometry.hpp b/libs/dgl/Geometry.hpp index 6c1b2da..1b0b22e 100644 --- a/libs/dgl/Geometry.hpp +++ b/libs/dgl/Geometry.hpp @@ -22,23 +22,74 @@ START_NAMESPACE_DGL // ----------------------------------------------------------------------- +// Forward class names + +template<typename> class Line; +template<typename> class Circle; +template<typename> class Triangle; +template<typename> class Rectangle; + +// ----------------------------------------------------------------------- +// Point template<typename T> class Point { public: + /** + Constructor for (0, 0) point. + */ Point() noexcept; - Point(T x, T y) noexcept; + + /** + Constructor using custom x and y values. + */ + Point(const T& x, const T& y) noexcept; + + /** + Constructor using another Point class values. + */ Point(const Point<T>& pos) noexcept; - T getX() const noexcept; - T getY() const noexcept; + /** + Get X value. + */ + const T& getX() const noexcept; + + /** + Get Y value. + */ + const T& getY() const noexcept; + + /** + Set X value as @a x. + */ + void setX(const T& x) noexcept; + + /** + Set Y value as @a y. + */ + void setY(const T& y) noexcept; + + /** + Set X and Y values as @a x and @a y respectively. + */ + void setPos(const T& x, const T& y) noexcept; + + /** + Set X and Y values according to @a pos. + */ + void setPos(const Point<T>& pos) noexcept; - void setX(T x) noexcept; - void setY(T y) noexcept; + /** + Move this point by @a x and @a y values. + */ + void moveBy(const T& x, const T& y) noexcept; - void move(T x, T y) noexcept; - void move(const Point<T>& pos) noexcept; + /** + Move this point by @a pos. + */ + void moveBy(const Point<T>& pos) noexcept; Point<T>& operator=(const Point<T>& pos) noexcept; Point<T>& operator+=(const Point<T>& pos) noexcept; @@ -48,88 +99,541 @@ public: private: T fX, fY; + template<typename> friend class Line; + template<typename> friend class Circle; + template<typename> friend class Triangle; template<typename> friend class Rectangle; - - DISTRHO_PREVENT_HEAP_ALLOCATION }; // ----------------------------------------------------------------------- +// Size template<typename T> class Size { public: + /** + Constructor for null size (0x0). + */ Size() noexcept; - Size(T width, T height) noexcept; + + /** + Constructor using custom width and height values. + */ + Size(const T& width, const T& height) noexcept; + + /** + Constructor using another Size class values. + */ Size(const Size<T>& size) noexcept; - T getWidth() const noexcept; - T getHeight() const noexcept; + /** + Get width. + */ + const T& getWidth() const noexcept; + + /** + Get height. + */ + const T& getHeight() const noexcept; + + /** + Set width. + */ + void setWidth(const T& width) noexcept; + + /** + Set height. + */ + void setHeight(const T& height) noexcept; + + /** + Set size using @a width and @a height. + */ + void setSize(const T& width, const T& height) noexcept; + + /** + Set size. + */ + void setSize(const Size<T>& size) noexcept; + + /** + Grow size by @a multiplier. + */ + void growBy(const T& multiplier) noexcept; - void setWidth(T width) noexcept; - void setHeight(T height) noexcept; + /** + Shrink size by @a divider. + */ + void shrinkBy(const T& divider) noexcept; Size<T>& operator=(const Size<T>& size) noexcept; Size<T>& operator+=(const Size<T>& size) noexcept; Size<T>& operator-=(const Size<T>& size) noexcept; - Size<T>& operator*=(T m) noexcept; - Size<T>& operator/=(T d) noexcept; + Size<T>& operator*=(const T& m) noexcept; + Size<T>& operator/=(const T& d) noexcept; bool operator==(const Size<T>& size) const noexcept; bool operator!=(const Size<T>& size) const noexcept; private: T fWidth, fHeight; template<typename> friend class Rectangle; +}; + +// ----------------------------------------------------------------------- +// Line + +template<typename T> +class Line +{ +public: + /** + Constructor for a null line ([0, 0] to [0, 0]). + */ + Line() noexcept; + + /** + Constructor using custom start X, start Y, end X and end Y values. + */ + Line(const T& startX, const T& startY, const T& endX, const T& endY) noexcept; + + /** + Constructor using custom start X, start Y, end pos values. + */ + Line(const T& startX, const T& startY, const Point<T>& endPos) noexcept; + + /** + Constructor using custom start pos, end X and end Y values. + */ + Line(const Point<T>& startPos, const T& endX, const T& endY) noexcept; + + /** + Constructor using custom start and end pos values. + */ + Line(const Point<T>& startPos, const Point<T>& endPos) noexcept; + + /** + Constructor using another Line class values. + */ + Line(const Line<T>& line) noexcept; + + /** + Get start X value. + */ + const T& getStartX() const noexcept; + + /** + Get start Y value. + */ + const T& getStartY() const noexcept; + + /** + Get end X value. + */ + const T& getEndX() const noexcept; + + /** + Get end Y value. + */ + const T& getEndY() const noexcept; + + /** + Get start position. + */ + const Point<T>& getStartPos() const noexcept; + + /** + Get end position. + */ + const Point<T>& getEndPos() const noexcept; + + /** + Set start X value as @a x. + */ + void setStartX(const T& x) noexcept; + + /** + Set start Y value as @a y. + */ + void setStartY(const T& y) noexcept; + + /** + Set start X and Y values as @a x and @a y respectively. + */ + void setStartPos(const T& x, const T& y) noexcept; + + /** + Set start X and Y values according to @a pos. + */ + void setStartPos(const Point<T>& pos) noexcept; + + /** + Set end X value as @a x. + */ + void setEndX(const T& x) noexcept; + + /** + Set end Y value as @a y. + */ + void setEndY(const T& y) noexcept; + + /** + Set end X and Y values as @a x and @a y respectively. + */ + void setEndPos(const T& x, const T& y) noexcept; + + /** + Set end X and Y values according to @a pos. + */ + void setEndPos(const Point<T>& pos) noexcept; + + /** + Move this line by @a x and @a y values. + */ + void moveBy(const T& x, const T& y) noexcept; + + /** + Move this line by @a pos. + */ + void moveBy(const Point<T>& pos) noexcept; + + /** + Draw this line using the current OpenGL state. + */ + void draw(); + + Line<T>& operator=(const Line<T>& line) noexcept; + bool operator==(const Line<T>& line) const noexcept; + bool operator!=(const Line<T>& line) const noexcept; + +private: + Point<T> fPosStart, fPosEnd; +}; + +// ----------------------------------------------------------------------- +// Circle + +template<typename T> +class Circle +{ +public: + /** + Constructor for a null circle. + */ + Circle() noexcept; + + /** + Constructor using custom X, Y and size values. + */ + Circle(const T& x, const T& y, float size, int numSegments = 300); + + /** + Constructor using custom position and size values. + */ + Circle(const Point<T>& pos, float size, int numSegments = 300); + + /** + Constructor using another Circle class values. + */ + Circle(const Circle<T>& cir) noexcept; + + /** + Get X value. + */ + const T& getX() const noexcept; + + /** + Get Y value. + */ + const T& getY() const noexcept; + + /** + Get position. + */ + const Point<T>& getPos() const noexcept; + + /** + Set X value as @a x. + */ + void setX(const T& x) noexcept; + + /** + Set Y value as @a y. + */ + void setY(const T& y) noexcept; + + /** + Set X and Y values as @a x and @a y respectively. + */ + void setPos(const T& x, const T& y) noexcept; + + /** + Set X and Y values according to @a pos. + */ + void setPos(const Point<T>& pos) noexcept; + + /** + Get size. + */ + float getSize() const noexcept; + + /** + Set size. + @note Must always be > 0.0f + */ + void setSize(float size) noexcept; + + /** + Get the current number of line segments that make this circle. + */ + int getNumSegments() const noexcept; + + /** + Set the number of line segments that will make this circle. + @note Must always be >= 3 + */ + void setNumSegments(int num); + + /** + Draw this circle using the current OpenGL state. + */ + void draw(); + + /** + Draw lines (outline of this circle) using the current OpenGL state. + */ + void drawOutline(); + + Circle<T>& operator=(const Circle<T>& cir) noexcept; + bool operator==(const Circle<T>& cir) const noexcept; + bool operator!=(const Circle<T>& cir) const noexcept; + +private: + Point<T> fPos; + float fSize; + int fNumSegments; + + // cached values + float fTheta, fCos, fSin; + + void _draw(const bool isOutline); +}; + +// ----------------------------------------------------------------------- +// Triangle + +template<typename T> +class Triangle +{ +public: + /** + Constructor for a null triangle. + */ + Triangle() noexcept; + + /** + Constructor using custom X and Y values. + */ + Triangle(const T& x1, const T& y1, const T& x2, const T& y2, const T& x3, const T& y3) noexcept; + + /** + Constructor using custom position values. + */ + Triangle(const Point<T>& pos1, const Point<T>& pos2, const Point<T>& pos3) noexcept; + + /** + Constructor using another Triangle class values. + */ + Triangle(const Triangle<T>& tri) noexcept; + + /** + Draw this triangle using the current OpenGL state. + */ + void draw(); + + /** + Draw lines (outline of this triangle) using the current OpenGL state. + */ + void drawOutline(); + + Triangle<T>& operator=(const Triangle<T>& tri) noexcept; + bool operator==(const Triangle<T>& tri) const noexcept; + bool operator!=(const Triangle<T>& tri) const noexcept; + +private: + Point<T> fPos1, fPos2, fPos3; - DISTRHO_PREVENT_HEAP_ALLOCATION + void _draw(const bool isOutline); }; // ----------------------------------------------------------------------- +// Rectangle template<typename T> class Rectangle { public: + /** + Constructor for a null rectangle. + */ Rectangle() noexcept; - Rectangle(T x, T y, T width, T height) noexcept; - Rectangle(T x, T y, const Size<T>& size) noexcept; - Rectangle(const Point<T>& pos, T width, T height) noexcept; + + /** + Constructor using custom X, Y, width and height values. + */ + Rectangle(const T& x, const T& y, const T& width, const T& height) noexcept; + + /** + Constructor using custom X, Y and size values. + */ + Rectangle(const T& x, const T& y, const Size<T>& size) noexcept; + + /** + Constructor using custom pos, width and height values. + */ + Rectangle(const Point<T>& pos, const T& width, const T& height) noexcept; + + /** + Constructor using custom position and size. + */ Rectangle(const Point<T>& pos, const Size<T>& size) noexcept; - Rectangle(const Rectangle<T>& rect) noexcept; - T getX() const noexcept; - T getY() const noexcept; - T getWidth() const noexcept; - T getHeight() const noexcept; + /** + Constructor using another Rectangle class values. + */ + Rectangle(const Rectangle<T>& rect) noexcept; + /** + Get X value. + */ + const T& getX() const noexcept; + + /** + Get Y value. + */ + const T& getY() const noexcept; + + /** + Get width. + */ + const T& getWidth() const noexcept; + + /** + Get height. + */ + const T& getHeight() const noexcept; + + /** + Get position. + */ const Point<T>& getPos() const noexcept; - const Size<T>& getSize() const noexcept; - bool contains(T x, T y) const noexcept; + /** + Get size. + */ + const Size<T>& getSize() const noexcept; + + /** + Set X value as @a x. + */ + void setX(const T& x) noexcept; + + /** + Set Y value as @a y. + */ + void setY(const T& y) noexcept; + + /** + Set X and Y values as @a x and @a y respectively. + */ + void setPos(const T& x, const T& y) noexcept; + + /** + Set X and Y values according to @a pos. + */ + void setPos(const Point<T>& pos) noexcept; + + /** + Move this rectangle by @a x and @a y values. + */ + void moveBy(const T& x, const T& y) noexcept; + + /** + Move this rectangle by @a pos. + */ + void moveBy(const Point<T>& pos) noexcept; + + /** + Set width. + */ + void setWidth(const T& width) noexcept; + + /** + Set height. + */ + void setHeight(const T& height) noexcept; + + /** + Set size using @a width and @a height. + */ + void setSize(const T& width, const T& height) noexcept; + + /** + Set size. + */ + void setSize(const Size<T>& size) noexcept; + + /** + Grow size by @a multiplier. + */ + void growBy(const T& multiplier) noexcept; + + /** + Shrink size by @a divider. + */ + void shrinkBy(const T& divider) noexcept; + + /** + Check if this rectangle contains the point defined by @a X and @a Y. + */ + bool contains(const T& x, const T& y) const noexcept; + + /** + Check if this rectangle contains the point @a pos. + */ bool contains(const Point<T>& pos) const noexcept; - bool containsX(T x) const noexcept; - bool containsY(T y) const noexcept; - void setX(T x) noexcept; - void setY(T y) noexcept; - void setPos(T x, T y) noexcept; - void setPos(const Point<T>& pos) noexcept; + /** + Check if this rectangle contains X. + */ + bool containsX(const T& x) const noexcept; - void move(T x, T y) noexcept; - void move(const Point<T>& pos) noexcept; + /** + Check if this rectangle contains Y. + */ + bool containsY(const T& y) const noexcept; - void setWidth(T width) noexcept; - void setHeight(T height) noexcept; - void setSize(T width, T height) noexcept; - void setSize(const Size<T>& size) noexcept; + /** + Draw this rectangle using the current OpenGL state. + */ + void draw(); + + /** + Draw lines (outline of this rectangle) using the current OpenGL state. + */ + void drawOutline(); Rectangle<T>& operator=(const Rectangle<T>& rect) noexcept; + Rectangle<T>& operator*=(const T& m) noexcept; + Rectangle<T>& operator/=(const T& d) noexcept; + bool operator==(const Rectangle<T>& size) const noexcept; + bool operator!=(const Rectangle<T>& size) const noexcept; private: Point<T> fPos; Size<T> fSize; - DISTRHO_PREVENT_HEAP_ALLOCATION + void _draw(const bool isOutline); }; // ----------------------------------------------------------------------- diff --git a/libs/dgl/Image.hpp b/libs/dgl/Image.hpp index 7a508f9..cf8d1e5 100644 --- a/libs/dgl/Image.hpp +++ b/libs/dgl/Image.hpp @@ -23,31 +23,109 @@ START_NAMESPACE_DGL // ----------------------------------------------------------------------- +/** + Base DGL Image class. + + This is an Image class that handles raw image data in pixels. + You can init the image data on the contructor or later on by calling loadFromMemory(). + + To generate raw data useful for this class see the utils/png2rgba.py script. + Be careful when using a PNG without alpha channel, for those the format is 'GL_BGR' + instead of the default 'GL_BGRA'. + + Images are drawn on screen via 2D textures. + */ class Image { public: - Image() noexcept; - Image(const char* rawData, int width, int height, GLenum format = GL_BGRA, GLenum type = GL_UNSIGNED_BYTE) noexcept; - Image(const char* rawData, const Size<int>& size, GLenum format = GL_BGRA, GLenum type = GL_UNSIGNED_BYTE) noexcept; - Image(const Image& image) noexcept; + /** + Constructor for a null Image. + */ + Image(); + + /** + Constructor using raw image data. + @note @a rawData must remain valid for the lifetime of this Image. + */ + Image(const char* rawData, int width, int height, GLenum format = GL_BGRA, GLenum type = GL_UNSIGNED_BYTE); + + /** + Constructor using raw image data. + @note @a rawData must remain valid for the lifetime of this Image. + */ + Image(const char* rawData, const Size<int>& size, GLenum format = GL_BGRA, GLenum type = GL_UNSIGNED_BYTE); + + /** + Constructor using another image data. + */ + Image(const Image& image); + + /** + Destructor. + */ ~Image(); + /** + Load image data from memory. + @note @a rawData must remain valid for the lifetime of this Image. + */ void loadFromMemory(const char* rawData, int width, int height, GLenum format = GL_BGRA, GLenum type = GL_UNSIGNED_BYTE) noexcept; + + /** + Load image data from memory. + @note @a rawData must remain valid for the lifetime of this Image. + */ void loadFromMemory(const char* rawData, const Size<int>& size, GLenum format = GL_BGRA, GLenum type = GL_UNSIGNED_BYTE) noexcept; + /** + Check if this image is valid. + */ bool isValid() const noexcept; + /** + Get width. + */ int getWidth() const noexcept; + + /** + Get height. + */ int getHeight() const noexcept; + + /** + Get size. + */ const Size<int>& getSize() const noexcept; + /** + Get the raw image data. + */ const char* getRawData() const noexcept; + + /** + Get the image format. + */ GLenum getFormat() const noexcept; + + /** + Get the image type. + */ GLenum getType() const noexcept; + /** + Draw this image at (0, 0) point. + */ void draw(); - void draw(int x, int y); - void draw(const Point<int>& pos); + + /** + Draw this image at (x, y) point. + */ + void drawAt(int x, int y); + + /** + Draw this image at position @a pos. + */ + void drawAt(const Point<int>& pos); Image& operator=(const Image& image) noexcept; bool operator==(const Image& image) const noexcept; @@ -59,8 +137,7 @@ private: GLenum fFormat; GLenum fType; GLuint fTextureId; - - DISTRHO_PREVENT_HEAP_ALLOCATION + bool fIsReady; }; // ----------------------------------------------------------------------- diff --git a/libs/dgl/ImageAboutWindow.hpp b/libs/dgl/ImageAboutWindow.hpp index c812295..3824064 100644 --- a/libs/dgl/ImageAboutWindow.hpp +++ b/libs/dgl/ImageAboutWindow.hpp @@ -21,12 +21,6 @@ #include "Widget.hpp" #include "Window.hpp" -#ifdef PROPER_CPP11_SUPPORT -# include <cstdint> -#else -# include <stdint.h> -#endif - START_NAMESPACE_DGL // ----------------------------------------------------------------------- @@ -35,15 +29,16 @@ class ImageAboutWindow : public Window, public Widget { public: - ImageAboutWindow(App& app, Window& parent, const Image& image = Image()); - ImageAboutWindow(Widget* widget, const Image& image = Image()); + explicit ImageAboutWindow(Window& parent, const Image& image = Image()); + explicit ImageAboutWindow(Widget* widget, const Image& image = Image()); void setImage(const Image& image); protected: void onDisplay() override; - bool onMouse(int button, bool press, int x, int y) override; - bool onKeyboard(bool press, uint32_t key) override; + bool onKeyboard(const KeyboardEvent&) override; + bool onMouse(const MouseEvent&) override; + void onReshape(int width, int height) override; private: Image fImgBackground; diff --git a/libs/dgl/ImageButton.hpp b/libs/dgl/ImageButton.hpp index 4d77466..f022d9b 100644 --- a/libs/dgl/ImageButton.hpp +++ b/libs/dgl/ImageButton.hpp @@ -34,18 +34,18 @@ public: virtual void imageButtonClicked(ImageButton* imageButton, int button) = 0; }; - ImageButton(Window& parent, const Image& image); - ImageButton(Widget* widget, const Image& image); - ImageButton(Window& parent, const Image& imageNormal, const Image& imageHover, const Image& imageDown); - ImageButton(Widget* widget, const Image& imageNormal, const Image& imageHover, const Image& imageDown); - ImageButton(const ImageButton& imageButton); + explicit ImageButton(Window& parent, const Image& image) noexcept; + explicit ImageButton(Window& parent, const Image& imageNormal, const Image& imageHover, const Image& imageDown) noexcept; + explicit ImageButton(Widget* widget, const Image& image) noexcept; + explicit ImageButton(Widget* widget, const Image& imageNormal, const Image& imageHover, const Image& imageDown) noexcept; + explicit ImageButton(const ImageButton& imageButton) noexcept; - void setCallback(Callback* callback); + void setCallback(Callback* callback) noexcept; protected: void onDisplay() override; - bool onMouse(int button, bool press, int x, int y) override; - bool onMotion(int x, int y) override; + bool onMouse(const MouseEvent&) override; + bool onMotion(const MotionEvent&) override; private: Image fImageNormal; diff --git a/libs/dgl/ImageKnob.hpp b/libs/dgl/ImageKnob.hpp index 057dcaf..a7a7e69 100644 --- a/libs/dgl/ImageKnob.hpp +++ b/libs/dgl/ImageKnob.hpp @@ -41,42 +41,43 @@ public: virtual void imageKnobValueChanged(ImageKnob* imageKnob, float value) = 0; }; - ImageKnob(Window& parent, const Image& image, Orientation orientation = Vertical); - ImageKnob(Widget* widget, const Image& image, Orientation orientation = Vertical); - ImageKnob(const ImageKnob& imageKnob); - - float getValue() const; - - void setOrientation(Orientation orientation); - void setRange(float min, float max); - void setLogScale(bool log = false); - void setStep(float step); - void setValue(float value, bool sendCallback = false); - void setDefault(float value); - void resetDefault(void); - void setRotationAngle(int angle); + explicit ImageKnob(Window& parent, const Image& image, Orientation orientation = Vertical, int id = 0) noexcept; + explicit ImageKnob(Widget* widget, const Image& image, Orientation orientation = Vertical, int id = 0) noexcept; + explicit ImageKnob(const ImageKnob& imageKnob); + ~ImageKnob() override; + + int getId() const noexcept; + void setId(int id) noexcept; + + float getValue() const noexcept; + + void setDefault(float def) noexcept; + void setRange(float min, float max) noexcept; + void setStep(float step) noexcept; + void setValue(float value, bool sendCallback = false) noexcept; + void setUsingLogScale(bool yesNo) noexcept; - void setCallback(Callback* callback); + void setCallback(Callback* callback) noexcept; + void setOrientation(Orientation orientation) noexcept; + void setRotationAngle(int angle); protected: void onDisplay() override; - bool onMouse(int button, bool press, int x, int y) override; - bool onScroll(int x, int y, float dx, float dy) override; - bool onMotion(int x, int y) override; - void onReshape(int width, int height) override; - void onClose() override; - float logscale(float value); - float invlogscale(float value); + bool onMouse(const MouseEvent&) override; + bool onMotion(const MotionEvent&) override; + bool onScroll(const ScrollEvent&) override; private: Image fImage; + int fId; float fMinimum; float fMaximum; float fStep; - bool fLog; float fValue; - float fValueTmp; float fValueDef; + float fValueTmp; + bool fUsingDefault; + bool fUsingLog; Orientation fOrientation; int fRotationAngle; @@ -92,6 +93,9 @@ private: Rectangle<int> fKnobArea; GLuint fTextureId; + float _logscale(float value) const; + float _invlogscale(float value) const; + DISTRHO_LEAK_DETECTOR(ImageKnob) }; diff --git a/libs/dgl/ImageSlider.hpp b/libs/dgl/ImageSlider.hpp index 31a26fc..d53edde 100644 --- a/libs/dgl/ImageSlider.hpp +++ b/libs/dgl/ImageSlider.hpp @@ -36,31 +36,35 @@ public: virtual void imageSliderValueChanged(ImageSlider* imageSlider, float value) = 0; }; - ImageSlider(Window& parent, const Image& image); - ImageSlider(Widget* widget, const Image& image); - ImageSlider(const ImageSlider& imageSlider); + explicit ImageSlider(Window& parent, const Image& image, int id = 0) noexcept; + explicit ImageSlider(Widget* widget, const Image& image, int id = 0) noexcept; + explicit ImageSlider(const ImageSlider& imageSlider) noexcept; - float getValue() const; + int getId() const noexcept; + void setId(int id) noexcept; - void setStartPos(const Point<int>& startPos); - void setStartPos(int x, int y); - void setEndPos(const Point<int>& endPos); - void setEndPos(int x, int y); + float getValue() const noexcept; - void setInverted(bool inverted); - void setRange(float min, float max); - void setStep(float step); - void setValue(float value, bool sendCallback = false); + void setStartPos(const Point<int>& startPos) noexcept; + void setStartPos(int x, int y) noexcept; + void setEndPos(const Point<int>& endPos) noexcept; + void setEndPos(int x, int y) noexcept; - void setCallback(Callback* callback); + void setInverted(bool inverted) noexcept; + void setRange(float min, float max) noexcept; + void setStep(float step) noexcept; + void setValue(float value, bool sendCallback = false) noexcept; + + void setCallback(Callback* callback) noexcept; protected: void onDisplay() override; - bool onMouse(int button, bool press, int x, int y) override; - bool onMotion(int x, int y) override; + bool onMouse(const MouseEvent&) override; + bool onMotion(const MotionEvent&) override; private: Image fImage; + int fId; float fMinimum; float fMaximum; float fStep; @@ -78,7 +82,14 @@ private: Point<int> fEndPos; Rectangle<int> fSliderArea; - void _recheckArea(); + void _recheckArea() noexcept; + + // these should not be used + void setAbsoluteX(int) const noexcept {} + void setAbsoluteY(int) const noexcept {} + void setAbsolutePos(int, int) const noexcept {} + void setAbsolutePos(const Point<int>&) const noexcept {} + void setNeedsFullViewport(bool) const noexcept {} DISTRHO_LEAK_DETECTOR(ImageSlider) }; diff --git a/libs/dgl/ImageToggle.hpp b/libs/dgl/ImageSwitch.hpp index bdec0e6..7f301b7 100644 --- a/libs/dgl/ImageToggle.hpp +++ b/libs/dgl/ImageSwitch.hpp @@ -1,7 +1,6 @@ /* * DISTRHO Plugin Framework (DPF) * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com> - * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * Permission to use, copy, modify, and/or distribute this software for any purpose with * or without fee is hereby granted, provided that the above copyright notice and this @@ -15,8 +14,8 @@ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#ifndef DGL_IMAGE_TOGGLE_HPP_INCLUDED -#define DGL_IMAGE_TOGGLE_HPP_INCLUDED +#ifndef DGL_IMAGE_SWITCH_HPP_INCLUDED +#define DGL_IMAGE_SWITCH_HPP_INCLUDED #include "Image.hpp" #include "Widget.hpp" @@ -25,43 +24,45 @@ START_NAMESPACE_DGL // ----------------------------------------------------------------------- -class ImageToggle : public Widget +class ImageSwitch : public Widget { public: class Callback { public: virtual ~Callback() {} - virtual void imageToggleClicked(ImageToggle* imageToggle, int button) = 0; + virtual void imageSwitchClicked(ImageSwitch* imageButton, bool down) = 0; }; - ImageToggle(Window& parent, const Image& image); - ImageToggle(Widget* widget, const Image& image); - ImageToggle(Window& parent, const Image& imageNormal, const Image& imageHover, const Image& imageDown); - ImageToggle(Widget* widget, const Image& imageNormal, const Image& imageHover, const Image& imageDown); - ImageToggle(const ImageToggle& imageToggle); + explicit ImageSwitch(Window& parent, const Image& imageNormal, const Image& imageDown, int id = 0) noexcept; + explicit ImageSwitch(Widget* widget, const Image& imageNormal, const Image& imageDown, int id = 0) noexcept; + explicit ImageSwitch(const ImageSwitch& imageSwitch) noexcept; - void setCallback(Callback* callback); - float getValue() override; - void setValue(float value) override; + int getId() const noexcept; + void setId(int id) noexcept; + + bool isDown() const noexcept; + void setDown(bool down) noexcept; + + void setCallback(Callback* callback) noexcept; protected: void onDisplay() override; - bool onMouse(int button, bool press, int x, int y) override; - bool onMotion(int x, int y) override; + bool onMouse(const MouseEvent&) override; private: - Image fImageNormal; - Image fImageHover; - Image fImageDown; - Image* fCurImage; - int fCurButton; + Image fImageNormal; + Image fImageDown; + bool fIsDown; + int fId; Callback* fCallback; + + DISTRHO_LEAK_DETECTOR(ImageSwitch) }; // ----------------------------------------------------------------------- END_NAMESPACE_DGL -#endif // DGL_IMAGE_TOGGLE_HPP_INCLUDED +#endif // DGL_IMAGE_SWITCH_HPP_INCLUDED diff --git a/libs/dgl/Makefile b/libs/dgl/Makefile index 1d9df69..484029e 100644 --- a/libs/dgl/Makefile +++ b/libs/dgl/Makefile @@ -16,18 +16,20 @@ LINK_FLAGS += $(DGL_LIBS) OBJS = \ src/App.cpp.o \ + src/Geometry.cpp.o \ src/Image.cpp.o \ src/ImageAboutWindow.cpp.o \ src/ImageButton.cpp.o \ - src/ImageToggle.cpp.o \ src/ImageKnob.cpp.o \ src/ImageSlider.cpp.o \ - src/Geometry.cpp.o \ - src/Widget.cpp.o \ - src/Window.cpp.o + src/ImageSwitch.cpp.o \ + src/NanoVG.cpp.o \ + src/Widget.cpp.o ifeq ($(MACOS),true) -OBJS += src/pugl/pugl_osx_extended.m.o +OBJS += src/Window.mm.o +else +OBJS += src/Window.cpp.o endif TARGET = ../libdgl.a @@ -39,21 +41,37 @@ all: $(TARGET) # -------------------------------------------------------------- ../libdgl.a: $(OBJS) - $(RM) $@ - $(AR) crs $@ $^ + rm -f $@ + ar crs $@ $^ + +../libdgl.dll: $(OBJS) + # -Wl,--output-def,$@.def,--out-implib,$@.a + $(CXX) $^ -shared $(LINK_FLAGS) -o $@ + +../libdgl.dylib: $(OBJS) + $(CXX) $^ -dynamiclib $(LINK_FLAGS) -o $@ + +../libdgl.so: $(OBJS) + $(CXX) $^ -shared $(LINK_FLAGS) -o $@ # -------------------------------------------------------------- +%.c.o: %.c + $(CC) $< $(BUILD_C_FLAGS) -c -o $@ + %.cpp.o: %.cpp $(CXX) $< $(BUILD_CXX_FLAGS) -c -o $@ %.m.o: %.m $(CC) $< $(BUILD_C_FLAGS) -ObjC -c -o $@ +%.mm.o: %.mm + $(CXX) $< $(BUILD_CXX_FLAGS) -ObjC++ -c -o $@ + # -------------------------------------------------------------- clean: - $(RM) src/*.o src/pugl/*.o ../libdgl.* + rm -f src/*.o src/pugl/*.o src/freetype-gl/*.o ../libdgl.* debug: $(MAKE) DEBUG=true diff --git a/libs/dgl/NanoVG.hpp b/libs/dgl/NanoVG.hpp new file mode 100644 index 0000000..f3b1b1d --- /dev/null +++ b/libs/dgl/NanoVG.hpp @@ -0,0 +1,828 @@ +/* + * DISTRHO Plugin Framework (DPF) + * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com> + * + * Permission to use, copy, modify, and/or distribute this software for any purpose with + * or without fee is hereby granted, provided that the above copyright notice and this + * permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD + * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN + * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER + * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef DGL_NANO_WIDGET_HPP_INCLUDED +#define DGL_NANO_WIDGET_HPP_INCLUDED + +#include "Widget.hpp" + +struct NVGcolor; +struct NVGcontext; +struct NVGpaint; + +START_NAMESPACE_DGL + +// ----------------------------------------------------------------------- +// NanoImage + +/** + NanoVG Image class. + + This implements NanoVG images as a C++ class where deletion is handled automatically. + Images need to be created within a NanoVG or NanoWidget class. + */ +class NanoImage +{ +public: + /** + Constructor for null image. + */ + NanoImage() noexcept; + + /** + Destructor. + */ + ~NanoImage(); + + /** + Check if this is a valid image. + */ + bool isValid() const noexcept; + + /** + Get size. + */ + Size<int> getSize() const; + + /** + Update image data. + */ + void updateImage(const uchar* data); + + /** + Operator =. + Takes the image data from @a img, invalidating it. + */ + NanoImage operator=(NanoImage img) noexcept; + +protected: + /** + Constructors are protected. + NanoImages must be created within a NanoVG or NanoWidget class. + */ + NanoImage(const char* filename); + NanoImage(uchar* data, int ndata); + NanoImage(int w, int h, const uchar* data); + +private: + NVGcontext* fContext; + int fImageId; + friend class NanoVG; +}; + +// ----------------------------------------------------------------------- +// NanoVG + +/** + NanoVG class. + + This class exposes the NanoVG drawing API. + All calls should be wrapped in beginFrame() & endFrame(). + + @section Color utils + Colors in NanoVG are stored as uints in ABGR format. + + @section State Handling + NanoVG contains state which represents how paths will be rendered. + The state contains transform, fill and stroke styles, text and font styles, and scissor clipping. + + @section Render styles + Fill and stroke render style can be either a solid color or a paint which is a gradient or a pattern. + Solid color is simply defined as a color value, different kinds of paints can be created + using linearGradient(), boxGradient(), radialGradient() and imagePattern(). + + Current render style can be saved and restored using save() and restore(). + + @section Transforms + The paths, gradients, patterns and scissor region are transformed by an transformation + matrix at the time when they are passed to the API. + The current transformation matrix is a affine matrix: + [sx kx tx] + [ky sy ty] + [ 0 0 1] + Where: sx,sy define scaling, kx,ky skewing, and tx,ty translation. + The last row is assumed to be 0,0,1 and is not stored. + + Apart from resetTransform(), each transformation function first creates + specific transformation matrix and pre-multiplies the current transformation by it. + + Current coordinate system (transformation) can be saved and restored using save() and restore(). + + @section Images + NanoVG allows you to load jpg, png, psd, tga, pic and gif files to be used for rendering. + In addition you can upload your own image. The image loading is provided by stb_image. + + @section Paints + NanoVG supports four types of paints: linear gradient, box gradient, radial gradient and image pattern. + These can be used as paints for strokes and fills. + + @section Scissoring + Scissoring allows you to clip the rendering into a rectangle. This is useful for varius + user interface cases like rendering a text edit or a timeline. + + @section Paths + Drawing a new shape starts with beginPath(), it clears all the currently defined paths. + Then you define one or more paths and sub-paths which describe the shape. The are functions + to draw common shapes like rectangles and circles, and lower level step-by-step functions, + which allow to define a path curve by curve. + + NanoVG uses even-odd fill rule to draw the shapes. Solid shapes should have counter clockwise + winding and holes should have counter clockwise order. To specify winding of a path you can + call pathWinding(). This is useful especially for the common shapes, which are drawn CCW. + + Finally you can fill the path using current fill style by calling fill(), and stroke it + with current stroke style by calling stroke(). + + The curve segments and sub-paths are transformed by the current transform. + + @section Text + NanoVG allows you to load .ttf files and use the font to render text. + + The appearance of the text can be defined by setting the current text style + and by specifying the fill color. Common text and font settings such as + font size, letter spacing and text align are supported. Font blur allows you + to create simple text effects such as drop shadows. + + At render time the font face can be set based on the font handles or name. + + Font measure functions return values in local space, the calculations are + carried in the same resolution as the final rendering. This is done because + the text glyph positions are snapped to the nearest pixels sharp rendering. + + The local space means that values are not rotated or scale as per the current + transformation. For example if you set font size to 12, which would mean that + line height is 16, then regardless of the current scaling and rotation, the + returned line height is always 16. Some measures may vary because of the scaling + since aforementioned pixel snapping. + + While this may sound a little odd, the setup allows you to always render the + same way regardless of scaling. I.e. following works regardless of scaling: + + @code + const char* txt = "Text me up."; + textBounds(vg, x,y, txt, NULL, bounds); + beginPath(vg); + roundedRect(vg, bounds[0],bounds[1], bounds[2]-bounds[0], bounds[3]-bounds[1]); + fill(vg); + @endcode + + Note: currently only solid color fill is supported for text. + */ +class NanoVG +{ +public: + enum Align { + // Horizontal align + ALIGN_LEFT = 1 << 0, // Align horizontally to left (default). + ALIGN_CENTER = 1 << 1, // Align horizontally to center. + ALIGN_RIGHT = 1 << 2, // Align horizontally to right. + // Vertical align + ALIGN_TOP = 1 << 3, // Align vertically to top. + ALIGN_MIDDLE = 1 << 4, // Align vertically to middle. + ALIGN_BOTTOM = 1 << 5, // Align vertically to bottom. + ALIGN_BASELINE = 1 << 6 // Align vertically to baseline (default). + }; + + enum Alpha { + STRAIGHT_ALPHA, + PREMULTIPLIED_ALPHA, + }; + + enum LineCap { + BUTT, + ROUND, + SQUARE, + BEVEL, + MITER + }; + + enum PatternRepeat { + REPEAT_NONE = 0x0, // No repeat + REPEAT_X = 0x1, // Repeat in X direction + REPEAT_Y = 0x2 // Repeat in Y direction + }; + + enum Solidity { + SOLID = 1, // CCW + HOLE = 2 // CW + }; + + enum Winding { + CCW = 1, // Winding for solid shapes + CW = 2 // Winding for holes + }; + + struct Color { + union { + float rgba[4]; + struct { float r,g,b,a; }; + }; + + Color() noexcept; + Color(const NVGcolor&) noexcept; + operator NVGcolor() const noexcept; + }; + + struct Paint { + float xform[6]; + float extent[2]; + float radius; + float feather; + Color innerColor; + Color outerColor; + int imageId; + PatternRepeat repeat; + + Paint() noexcept; + Paint(const NVGpaint&) noexcept; + operator NVGpaint() const noexcept; + }; + + struct GlyphPosition { + const char* str; // Position of the glyph in the input string. + float x; // The x-coordinate of the logical glyph position. + float minx, maxx; // The bounds of the glyph shape. + }; + + struct TextRow { + const char* start; // Pointer to the input text where the row starts. + const char* end; // Pointer to the input text where the row ends (one past the last character). + const char* next; // Pointer to the beginning of the next row. + float width; // Logical width of the row. + float minx, maxx; // Actual bounds of the row. Logical with and bounds can differ because of kerning and some parts over extending. + }; + + typedef int FontId; + + /** + Constructor. + Uses 512x512 as default atlas size. + */ + NanoVG(); + + /** + Constructor using custom text atlas size. + */ + NanoVG(int textAtlasWidth, int textAtlasHeight); + + /** + Destructor. + */ + ~NanoVG(); + + /** + Get the NanoVG context. + You should not need this under normal circumstances. + */ + NVGcontext* getContext() const noexcept + { + return fContext; + } + + /** + Begin drawing a new frame. + @param withAlha Controls if drawing the shapes to the render target should be done using straight or pre-multiplied alpha. + */ + void beginFrame(int width, int height, float scaleFactor = 1.0f, Alpha alpha = PREMULTIPLIED_ALPHA); + + /** + Ends drawing flushing remaining render state. + */ + void endFrame(); + + /* -------------------------------------------------------------------- + * Color utils */ + + /** + Returns a color value from red, green, blue values. Alpha will be set to 255 (1.0f). + */ + static Color RGB(uchar r, uchar g, uchar b); + + /** + Returns a color value from red, green, blue values. Alpha will be set to 1.0f. + */ + static Color RGBf(float r, float g, float b); + + /** + Returns a color value from red, green, blue and alpha values. + */ + static Color RGBA(uchar r, uchar g, uchar b, uchar a); + + /** + Returns a color value from red, green, blue and alpha values. + */ + static Color RGBAf(float r, float g, float b, float a); + + /** + Linearly interpolates from color c0 to c1, and returns resulting color value. + */ + static Color lerpRGBA(const Color& c0, const Color& c1, float u); + + /** + Returns color value specified by hue, saturation and lightness. + HSL values are all in range [0..1], alpha will be set to 255. + */ + static Color HSL(float h, float s, float l); + + /** + Returns color value specified by hue, saturation and lightness and alpha. + HSL values are all in range [0..1], alpha in range [0..255] + */ + static Color HSLA(float h, float s, float l, uchar a); + + /* -------------------------------------------------------------------- + * State Handling */ + + /** + Pushes and saves the current render state into a state stack. + A matching restore() must be used to restore the state. + */ + void save(); + + /** + Pops and restores current render state. + */ + void restore(); + + /** + Resets current render state to default values. Does not affect the render state stack. + */ + void reset(); + + /* -------------------------------------------------------------------- + * Render styles */ + + /** + Sets current stroke style to a solid color. + */ + void strokeColor(const Color& color); + + /** + Sets current stroke style to a paint, which can be a one of the gradients or a pattern. + */ + void strokePaint(const Paint& paint); + + /** + Sets current fill style to a solid color. + */ + void fillColor(const Color& color); + + /** + Sets current fill style to a paint, which can be a one of the gradients or a pattern. + */ + void fillPaint(const Paint& paint); + + /** + Sets the miter limit of the stroke style. + Miter limit controls when a sharp corner is beveled. + */ + void miterLimit(float limit); + + /** + Sets the stroke width of the stroke style. + */ + void strokeWidth(float size); + + /** + Sets how the end of the line (cap) is drawn, + Can be one of: BUTT, ROUND, SQUARE. + */ + void lineCap(LineCap cap = BUTT); + + /** + Sets how sharp path corners are drawn. + Can be one of MITER, ROUND, BEVEL. + */ + void lineJoin(LineCap join = MITER); + + /* -------------------------------------------------------------------- + * Transforms */ + + /** + Resets current transform to a identity matrix. + */ + void resetTransform(); + + /** + Pre-multiplies current coordinate system by specified matrix. + The parameters are interpreted as matrix as follows: + [a c e] + [b d f] + [0 0 1] + */ + void transform(float a, float b, float c, float d, float e, float f); + + /** + Translates current coordinate system. + */ + void translate(float x, float y); + + /** + Rotates current coordinate system. Angle is specified in radians. + */ + void rotate(float angle); + + /** + Skews the current coordinate system along X axis. Angle is specified in radians. + */ + void skewX(float angle); + + /** + Skews the current coordinate system along Y axis. Angle is specified in radians. + */ + void skewY(float angle); + + /** + Scales the current coordinate system. + */ + void scale(float x, float y); + + /** + Stores the top part (a-f) of the current transformation matrix in to the specified buffer. + [a c e] + [b d f] + [0 0 1] + */ + void currentTransform(float xform[6]); + + /** + The following functions can be used to make calculations on 2x3 transformation matrices. + A 2x3 matrix is represented as float[6]. */ + + /** + Sets the transform to identity matrix. + */ + static void transformIdentity(float dst[6]); + + /** + Sets the transform to translation matrix matrix. + */ + static void transformTranslate(float dst[6], float tx, float ty); + + /** + Sets the transform to scale matrix. + */ + static void transformScale(float dst[6], float sx, float sy); + + /** + Sets the transform to rotate matrix. Angle is specified in radians. + */ + static void transformRotate(float dst[6], float a); + + /** + Sets the transform to skew-x matrix. Angle is specified in radians. + */ + static void transformSkewX(float dst[6], float a); + + /** + Sets the transform to skew-y matrix. Angle is specified in radians. + */ + static void transformSkewY(float dst[6], float a); + + /** + Sets the transform to the result of multiplication of two transforms, of A = A*B. + */ + static void transformMultiply(float dst[6], const float src[6]); + + /** + Sets the transform to the result of multiplication of two transforms, of A = B*A. + */ + static void transformPremultiply(float dst[6], const float src[6]); + + /** + Sets the destination to inverse of specified transform. + Returns 1 if the inverse could be calculated, else 0. + */ + static int transformInverse(float dst[6], const float src[6]); + + /** + Transform a point by given transform. + */ + static void transformPoint(float& dstx, float& dsty, const float xform[6], float srcx, float srcy); + + /** + Convert degrees to radians. + */ + static float degToRad(float deg); + + /** + Convert radians to degrees. + */ + static float radToDeg(float rad); + + /* -------------------------------------------------------------------- + * Images */ + + /** + Creates image by loading it from the disk from specified file name. + */ + NanoImage createImage(const char* filename); + + /** + Creates image by loading it from the specified chunk of memory. + */ + NanoImage createImageMem(uchar* data, int ndata); + + /** + Creates image from specified image data. + */ + NanoImage createImageRGBA(int w, int h, const uchar* data); + + /* -------------------------------------------------------------------- + * Paints */ + + /** + Creates and returns a linear gradient. Parameters (sx,sy)-(ex,ey) specify the start and end coordinates + of the linear gradient, icol specifies the start color and ocol the end color. + The gradient is transformed by the current transform when it is passed to fillPaint() or strokePaint(). + */ + Paint linearGradient(float sx, float sy, float ex, float ey, const Color& icol, const Color& ocol); + + /** + Creates and returns a box gradient. Box gradient is a feathered rounded rectangle, it is useful for rendering + drop shadows or highlights for boxes. Parameters (x,y) define the top-left corner of the rectangle, + (w,h) define the size of the rectangle, r defines the corner radius, and f feather. Feather defines how blurry + the border of the rectangle is. Parameter icol specifies the inner color and ocol the outer color of the gradient. + The gradient is transformed by the current transform when it is passed to fillPaint() or strokePaint(). + */ + Paint boxGradient(float x, float y, float w, float h, float r, float f, const Color& icol, const Color& ocol); + + /** + Creates and returns a radial gradient. Parameters (cx,cy) specify the center, inr and outr specify + the inner and outer radius of the gradient, icol specifies the start color and ocol the end color. + The gradient is transformed by the current transform when it is passed to fillPaint() or strokePaint(). + */ + Paint radialGradient(float cx, float cy, float inr, float outr, const Color& icol, const Color& ocol); + + /** + Creates and returns an image patter. Parameters (ox,oy) specify the left-top location of the image pattern, + (ex,ey) the size of one image, angle rotation around the top-left corner, image is handle to the image to render, + and repeat tells if the image should be repeated across x or y. + The gradient is transformed by the current transform when it is passed to fillPaint() or strokePaint(). + */ + Paint imagePattern(float ox, float oy, float ex, float ey, float angle, const NanoImage& image, PatternRepeat repeat); + + /* -------------------------------------------------------------------- + * Scissoring */ + + /** + Sets the current + The scissor rectangle is transformed by the current transform. + */ + void scissor(float x, float y, float w, float h); + + /** + Reset and disables scissoring. + */ + void resetScissor(); + + /* -------------------------------------------------------------------- + * Paths */ + + /** + Clears the current path and sub-paths. + */ + void beginPath(); + + /** + Starts new sub-path with specified point as first point. + */ + void moveTo(float x, float y); + + /** + Adds line segment from the last point in the path to the specified point. + */ + void lineTo(float x, float y); + + /** + Adds bezier segment from last point in the path via two control points to the specified point. + */ + void bezierTo(float c1x, float c1y, float c2x, float c2y, float x, float y); + + /** + Adds an arc segment at the corner defined by the last path point, and two specified points. + */ + void arcTo(float x1, float y1, float x2, float y2, float radius); + + /** + Closes current sub-path with a line segment. + */ + void closePath(); + + /** + Sets the current sub-path winding. + */ + void pathWinding(Winding dir); + + /** + Creates new arc shaped sub-path. + */ + void arc(float cx, float cy, float r, float a0, float a1, Winding dir); + + /** + Creates new rectangle shaped sub-path. + */ + void rect(float x, float y, float w, float h); + + /** + Creates new rounded rectangle shaped sub-path. + */ + void roundedRect(float x, float y, float w, float h, float r); + + /** + Creates new ellipse shaped sub-path. + */ + void ellipse(float cx, float cy, float rx, float ry); + + /** + Creates new circle shaped sub-path. + */ + void circle(float cx, float cy, float r); + + /** + Fills the current path with current fill style. + */ + void fill(); + + /** + Fills the current path with current stroke style. + */ + void stroke(); + + /* -------------------------------------------------------------------- + * Text */ + + /** + Creates font by loading it from the disk from specified file name. + Returns handle to the font. + */ + FontId createFont(const char* name, const char* filename); + + /** + Creates font by loading it from the specified memory chunk. + Returns handle to the font. + */ + FontId createFontMem(const char* name, uchar* data, int ndata, bool freeData); + + /** + Finds a loaded font of specified name, and returns handle to it, or -1 if the font is not found. + */ + FontId findFont(const char* name); + + /** + Sets the font size of current text style. + */ + void fontSize(float size); + + /** + Sets the blur of current text style. + */ + void fontBlur(float blur); + + /** + Sets the letter spacing of current text style. + */ + void textLetterSpacing(float spacing); + + /** + Sets the proportional line height of current text style. The line height is specified as multiple of font size. + */ + void textLineHeight(float lineHeight); + + /** + Sets the text align of current text style. + */ + void textAlign(Align align); + + /** + Sets the text align of current text style. + Overloaded function for convenience. + @see Align + */ + void textAlign(int align); + + /** + Sets the font face based on specified id of current text style. + */ + void fontFaceId(FontId font); + + /** + Sets the font face based on specified name of current text style. + */ + void fontFace(const char* font); + + /** + Draws text string at specified location. If end is specified only the sub-string up to the end is drawn. + */ + float text(float x, float y, const char* string, const char* end); + + /** + Draws multi-line text string at specified location wrapped at the specified width. If end is specified only the sub-string up to the end is drawn. + White space is stripped at the beginning of the rows, the text is split at word boundaries or when new-line characters are encountered. + Words longer than the max width are slit at nearest character (i.e. no hyphenation). + */ + void textBox(float x, float y, float breakRowWidth, const char* string, const char* end); + + /** + Measures the specified text string. The bounds value are [xmin,ymin, xmax,ymax]. + Returns the horizontal advance of the measured text (i.e. where the next character should drawn). + Measured values are returned in local coordinate space. + */ + float textBounds(float x, float y, const char* string, const char* end, Rectangle<float>& bounds); + + /** + Measures the specified multi-text string. Parameter bounds should be a pointer to float[4], + if the bounding box of the text should be returned. The bounds value are [xmin,ymin, xmax,ymax] + Measured values are returned in local coordinate space. + */ + void textBoxBounds(float x, float y, float breakRowWidth, const char* string, const char* end, float* bounds); + + /** + Calculates the glyph x positions of the specified text. If end is specified only the sub-string will be used. + Measured values are returned in local coordinate space. + */ + int textGlyphPositions(float x, float y, const char* string, const char* end, GlyphPosition* positions, int maxPositions); + + /** + Returns the vertical metrics based on the current text style. + Measured values are returned in local coordinate space. + */ + void textMetrics(float* ascender, float* descender, float* lineh); + + /** + Breaks the specified text into lines. If end is specified only the sub-string will be used. + White space is stripped at the beginning of the rows, the text is split at word boundaries or when new-line characters are encountered. + Words longer than the max width are slit at nearest character (i.e. no hyphenation). + */ + int textBreakLines(const char* string, const char* end, float breakRowWidth, TextRow* rows, int maxRows); + +private: + NVGcontext* const fContext; + + DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(NanoVG) +}; + +// ----------------------------------------------------------------------- +// NanoWidget + +/** + NanoVG Widget class. + + This class implements the NanoVG drawing API inside a DGL Widget. + The drawing function onDisplay() is implemented internally but a + new onNanoDisplay() needs to be overridden instead. + */ +class NanoWidget : public Widget, + public NanoVG +{ +public: + /** + Constructor. + */ + NanoWidget(Window& parent) + : Widget(parent), + NanoVG() {} + +protected: + /** + New virtual onDisplay function. + @see onDisplay + */ + virtual void onNanoDisplay() = 0; + +private: + /** + Widget display function. + Implemented internally to wrap begin/endFrame() automaticaly. + */ + void onDisplay() override + { + //glPushAttrib(GL_PIXEL_MODE_BIT|GL_STENCIL_BUFFER_BIT|GL_ENABLE_BIT); + beginFrame(getWidth(), getHeight()); + onNanoDisplay(); + endFrame(); + //glPopAttrib(); + glDisable(GL_CULL_FACE); + } + + DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(NanoWidget) +}; + +// ----------------------------------------------------------------------- + +END_NAMESPACE_DGL + +#endif // DGL_NANO_WIDGET_HPP_INCLUDED diff --git a/libs/dgl/StandaloneWindow.hpp b/libs/dgl/StandaloneWindow.hpp index e5203ee..05a7185 100644 --- a/libs/dgl/StandaloneWindow.hpp +++ b/libs/dgl/StandaloneWindow.hpp @@ -18,59 +18,59 @@ #define DGL_STANDALONE_WINDOW_HPP_INCLUDED #include "App.hpp" +#include "Widget.hpp" #include "Window.hpp" START_NAMESPACE_DGL // ----------------------------------------------------------------------- -class StandaloneWindow +class StandaloneWindow : public App, + public Window { public: StandaloneWindow() - : fApp(), - fWindow(fApp) - { - } - - App& getApp() noexcept - { - return fApp; - } - - Window& getWindow() noexcept - { - return fWindow; - } + : App(), + Window((App&)*this), + fWidget(nullptr) {} void exec() { - fWindow.show(); - fApp.exec(); + Window::show(); + App::exec(); } - // ------------------------------------------------------------------- - // helpers - - void setResizable(bool yesNo) +protected: + void onReshape(int width, int height) override { - fWindow.setResizable(yesNo); + if (fWidget != nullptr) + fWidget->setSize(width, height); + Window::onReshape(width, height); } - void setSize(unsigned int width, unsigned int height) +private: + Widget* fWidget; + + void _addWidget(Widget* widget) override { - fWindow.setSize(width, height); + if (fWidget == nullptr) + { + fWidget = widget; + fWidget->setNeedsFullViewport(true); + } + Window::_addWidget(widget); } - void setTitle(const char* title) + void _removeWidget(Widget* widget) override { - fWindow.setTitle(title); + if (fWidget == widget) + { + fWidget->setNeedsFullViewport(false); + fWidget = nullptr; + } + Window::_removeWidget(widget); } -protected: - App fApp; - Window fWindow; - DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(StandaloneWindow) }; diff --git a/libs/dgl/Widget.hpp b/libs/dgl/Widget.hpp index 8345621..5d112aa 100644 --- a/libs/dgl/Widget.hpp +++ b/libs/dgl/Widget.hpp @@ -19,84 +19,300 @@ #include "Geometry.hpp" -#ifdef PROPER_CPP11_SUPPORT -# include <cstdint> -#else -# include <stdint.h> -#endif - START_NAMESPACE_DGL // ----------------------------------------------------------------------- +// Forward class names class App; class Window; +// ----------------------------------------------------------------------- + +/** + Base DGL Widget class. + + This is the base Widget class, from which all widgets are built. + + All widgets have a parent Window where they'll be drawn. + This parent is never changed during the widget lifetime. + + Widgets receive events in relative coordinates. + (0, 0) means its top-left position. + + Windows paint widgets in the order they are constructed. + Early widgets are drawn first, at the bottom, then newer ones on top. + Events are sent in the inverse order so that the top-most widget gets + a chance to catch the event and stop its propagation. + + All widget event callbacks do nothing by default. + */ class Widget { public: - Widget(Window& parent); + /** + Base event data. + @param mod The currently active modifiers. + @param time The timestamp (if any) of the currently-processing event. + */ + struct BaseEvent { + Modifier mod; + uint32_t time; + }; + + /** + Keyboard event. + @param press True if the key was pressed, false if released. + @param key Unicode point of the key pressed. + @see onKeyboard + */ + struct KeyboardEvent : BaseEvent { + bool press; + uint key; + }; + + /** + Special keyboard event. + @param press True if the key was pressed, false if released. + @param key The key pressed. + @see onSpecial + */ + struct SpecialEvent : BaseEvent { + bool press; + Key key; + }; + + /** + Mouse event. + @param button The button number (1 = left, 2 = middle, 3 = right). + @param press True if the key was pressed, false if released. + @param pos The widget-relative coordinates of the pointer. + @see onMouse + */ + struct MouseEvent : BaseEvent { + int button; + bool press; + Point<int> pos; + }; + + /** + Mouse motion event. + @param pos The widget-relative coordinates of the pointer. + @see onMotion + */ + struct MotionEvent : BaseEvent { + Point<int> pos; + }; + + /** + Mouse scroll event. + @param pos The widget-relative coordinates of the pointer. + @param delta The scroll distance. + @see onScroll + */ + struct ScrollEvent : BaseEvent { + Point<int> pos; + Point<float> delta; + }; + + /** + Resize event. + @param size The new widget size. + @param oldSize The previous size, may be null. + @see onResize + */ + struct ResizeEvent { + Size<int> size; + Size<int> oldSize; + }; + + /** + Constructor. + */ + explicit Widget(Window& parent); + + /** + Destructor. + */ virtual ~Widget(); + /** + Check if this widget is visible within its parent window. + Invisible widgets do not receive events except resize. + */ bool isVisible() const noexcept; + + /** + Set widget visible (or not) according to @a yesNo. + */ void setVisible(bool yesNo); + /** + Show widget. + This is the same as calling setVisible(true). + */ void show(); - void hide(); - - int getX() const noexcept; - int getY() const noexcept; - const Point<int>& getPos() const noexcept; - - void setX(int x); - void setY(int y); - void setPos(int x, int y); - void setPos(const Point<int>& pos); - void move(int x, int y); - void move(const Point<int>& pos); + /** + Hide widget. + This is the same as calling setVisible(false). + */ + void hide(); + /** + Get width. + */ int getWidth() const noexcept; + + /** + Get height. + */ int getHeight() const noexcept; + + /** + Get size. + */ const Size<int>& getSize() const noexcept; - // virtual needed by cairo - virtual void setWidth(int width); - virtual void setHeight(int height); - virtual void setSize(const Size<int>& size); + /** + Set width. + */ + virtual void setWidth(int width) noexcept; + + /** + Set height. + */ + virtual void setHeight(int height) noexcept; + + /** + Set size using @a width and @a height values. + */ + virtual void setSize(int width, int height) noexcept; + + /** + Set size. + */ + virtual void setSize(const Size<int>& size) noexcept; + + /** + Get absolute X. + */ + int getAbsoluteX() const noexcept; + + /** + Get absolute Y. + */ + int getAbsoluteY() const noexcept; + + /** + Get absolute position. + */ + const Point<int>& getAbsolutePos() const noexcept; + + /** + Set absolute X. + */ + void setAbsoluteX(int x) noexcept; - void setSize(int width, int height) - { - setSize(Size<int>(width, height)); - } + /** + Set absolute Y. + */ + void setAbsoluteY(int y) noexcept; - const Rectangle<int>& getArea() const noexcept; + /** + Set absolute position using @a x and @a y values. + */ + void setAbsolutePos(int x, int y) noexcept; - uint32_t getEventTimestamp(); - int getModifiers(); + /** + Set absolute position. + */ + void setAbsolutePos(const Point<int>& pos) noexcept; + /** + Get this widget's window application. + Same as calling getParentWindow().getApp(). + */ App& getParentApp() const noexcept; + + /** + Get parent window, as passed in the constructor. + */ Window& getParentWindow() const noexcept; - void repaint(); + /** + Check if this widget contains the point defined by @a X and @a Y. + */ + bool contains(int x, int y) const noexcept; + + /** + Check if this widget contains the point @a pos. + */ + bool contains(const Point<int>& pos) const noexcept; + + /** + Tell this widget's window to repaint itself. + */ + void repaint() noexcept; protected: + /** + A function called to draw the view contents with OpenGL. + */ virtual void onDisplay() = 0; - virtual bool onKeyboard(bool press, uint32_t key); - virtual bool onMouse(int button, bool press, int x, int y); - virtual bool onMotion(int x, int y); - virtual bool onScroll(int x, int y, float dx, float dy); - virtual bool onSpecial(bool press, Key key); - virtual void onReshape(int width, int height); - virtual void onClose(); + + /** + A function called when a key is pressed or released. + @return True to stop event propagation, false otherwise. + */ + virtual bool onKeyboard(const KeyboardEvent&); + + /** + A function called when a special key is pressed or released. + @return True to stop event propagation, false otherwise. + */ + virtual bool onSpecial(const SpecialEvent&); + + /** + A function called when a mouse button is pressed or released. + @return True to stop event propagation, false otherwise. + */ + virtual bool onMouse(const MouseEvent&); + + /** + A function called when the pointer moves. + @return True to stop event propagation, false otherwise. + */ + virtual bool onMotion(const MotionEvent&); + + /** + A function called on scrolling (e.g. mouse wheel or track pad). + @return True to stop event propagation, false otherwise. + */ + virtual bool onScroll(const ScrollEvent&); + + /** + A function called when the widget is resized. + */ + virtual void onResize(const ResizeEvent&); + + /** + Tell the parent window this widget this the full viewport. + When enabled, the local widget coordinates are ignored. + @note: This is an internal function; + You do not need it under normal circumstances. + */ + void setNeedsFullViewport(bool yesNo) noexcept; private: Window& fParent; + bool fNeedsFullViewport; bool fVisible; Rectangle<int> fArea; friend class CairoWidget; friend class Window; + friend class StandaloneWindow; DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(Widget) }; diff --git a/libs/dgl/Window.hpp b/libs/dgl/Window.hpp index d78479e..f52c141 100644 --- a/libs/dgl/Window.hpp +++ b/libs/dgl/Window.hpp @@ -19,12 +19,6 @@ #include "Geometry.hpp" -#ifdef PROPER_CPP11_SUPPORT -# include <cstdint> -#else -# include <stdint.h> -#endif - START_NAMESPACE_DGL // ----------------------------------------------------------------------- @@ -35,9 +29,9 @@ class Widget; class Window { public: - Window(App& app); - Window(App& app, Window& parent); - Window(App& app, intptr_t parentId); + explicit Window(App& app); + explicit Window(App& app, Window& parent); + explicit Window(App& app, intptr_t parentId); virtual ~Window(); void show(); @@ -46,7 +40,7 @@ public: void exec(bool lockWait = false); void focus(); - void repaint(); + void repaint() noexcept; bool isVisible() const noexcept; void setVisible(bool yesNo); @@ -56,26 +50,35 @@ public: int getWidth() const noexcept; int getHeight() const noexcept; - Size<int> getSize() const noexcept; - void setSize(unsigned int width, unsigned int height); + Size<uint> getSize() const noexcept; + void setSize(uint width, uint height); + void setSize(Size<uint> size); void setTitle(const char* title); void setTransientWinId(intptr_t winId); - App& getApp() const noexcept; - uint32_t getEventTimestamp() const; - int getModifiers() const; - intptr_t getWindowId() const; + App& getApp() const noexcept; + intptr_t getWindowId() const noexcept; + + void addIdleCallback(IdleCallback* const callback); + void removeIdleCallback(IdleCallback* const callback); + +protected: + virtual void onDisplayBefore(); + virtual void onDisplayAfter(); + virtual void onReshape(int width, int height); + virtual void onClose(); private: - class PrivateData; + struct PrivateData; PrivateData* const pData; friend class App; friend class Widget; + friend class StandaloneWindow; - void _addWidget(Widget* const widget); - void _removeWidget(Widget* const widget); + virtual void _addWidget(Widget* const widget); + virtual void _removeWidget(Widget* const widget); void _idle(); DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(Window) diff --git a/libs/dgl/src/App.cpp b/libs/dgl/src/App.cpp index 1b37ca3..754e44e 100644 --- a/libs/dgl/src/App.cpp +++ b/libs/dgl/src/App.cpp @@ -14,28 +14,13 @@ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#include "../App.hpp" +#include "AppPrivateData.hpp" #include "../Window.hpp" -#include <list> - START_NAMESPACE_DGL // ----------------------------------------------------------------------- -struct App::PrivateData { - bool doLoop; - unsigned visibleWindows; - std::list<Window*> windows; - std::list<IdleCallback*> idleCallbacks; - - PrivateData() - : doLoop(false), - visibleWindows(0) {} -}; - -// ----------------------------------------------------------------------- - App::App() : pData(new PrivateData()) { @@ -43,20 +28,18 @@ App::App() App::~App() { - pData->windows.clear(); - pData->idleCallbacks.clear(); delete pData; } void App::idle() { - for (std::list<Window*>::iterator it = pData->windows.begin(); it != pData->windows.end(); ++it) + for (std::list<Window*>::iterator it = pData->windows.begin(), ite = pData->windows.end(); it != ite; ++it) { Window* const window(*it); window->_idle(); } - for (std::list<IdleCallback*>::iterator it = pData->idleCallbacks.begin(); it != pData->idleCallbacks.end(); ++it) + for (std::list<IdleCallback*>::iterator it = pData->idleCallbacks.begin(), ite = pData->idleCallbacks.end(); it != ite; ++it) { IdleCallback* const idleCallback(*it); idleCallback->idleCallback(); @@ -65,7 +48,7 @@ void App::idle() void App::exec() { - while (pData->doLoop) + for (; pData->doLoop;) { idle(); d_msleep(10); @@ -76,58 +59,18 @@ void App::quit() { pData->doLoop = false; - for (std::list<Window*>::reverse_iterator rit = pData->windows.rbegin(); rit != pData->windows.rend(); ++rit) + for (std::list<Window*>::reverse_iterator rit = pData->windows.rbegin(), rite = pData->windows.rend(); rit != rite; ++rit) { Window* const window(*rit); window->close(); } } -bool App::isQuiting() const +bool App::isQuiting() const noexcept { return !pData->doLoop; } // ----------------------------------------------------------------------- -void App::addIdleCallback(IdleCallback* const callback) -{ - if (callback != nullptr) - pData->idleCallbacks.push_back(callback); -} - -void App::removeIdleCallback(IdleCallback* const callback) -{ - if (callback != nullptr) - pData->idleCallbacks.remove(callback); -} - -// ----------------------------------------------------------------------- - -void App::_addWindow(Window* const window) -{ - if (window != nullptr) - pData->windows.push_back(window); -} - -void App::_removeWindow(Window* const window) -{ - if (window != nullptr) - pData->windows.remove(window); -} - -void App::_oneShown() -{ - if (++pData->visibleWindows == 1) - pData->doLoop = true; -} - -void App::_oneHidden() -{ - if (--pData->visibleWindows == 0) - pData->doLoop = false; -} - -// ----------------------------------------------------------------------- - END_NAMESPACE_DGL diff --git a/libs/dgl/src/AppPrivateData.hpp b/libs/dgl/src/AppPrivateData.hpp new file mode 100644 index 0000000..05f7003 --- /dev/null +++ b/libs/dgl/src/AppPrivateData.hpp @@ -0,0 +1,67 @@ +/* + * DISTRHO Plugin Framework (DPF) + * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com> + * + * Permission to use, copy, modify, and/or distribute this software for any purpose with + * or without fee is hereby granted, provided that the above copyright notice and this + * permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD + * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN + * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER + * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef DGL_APP_PRIVATE_DATA_HPP_INCLUDED +#define DGL_APP_PRIVATE_DATA_HPP_INCLUDED + +#include "../App.hpp" +#include "../../distrho/extra/d_sleep.hpp" + +#include <list> + +START_NAMESPACE_DGL + +// ----------------------------------------------------------------------- + +struct App::PrivateData { + bool doLoop; + uint visibleWindows; + std::list<Window*> windows; + std::list<IdleCallback*> idleCallbacks; + + PrivateData() + : doLoop(false), + visibleWindows(0) {} + + ~PrivateData() + { + DISTRHO_SAFE_ASSERT(! doLoop); + DISTRHO_SAFE_ASSERT(visibleWindows == 0); + + windows.clear(); + idleCallbacks.clear(); + } + + void oneShown() noexcept + { + if (++visibleWindows == 1) + doLoop = true; + } + + void oneHidden() noexcept + { + DISTRHO_SAFE_ASSERT_RETURN(visibleWindows > 0,); + + if (--visibleWindows == 0) + doLoop = false; + } +}; + +// ----------------------------------------------------------------------- + +END_NAMESPACE_DGL + +#endif // DGL_APP_PRIVATE_DATA_HPP_INCLUDED diff --git a/libs/dgl/src/Geometry.cpp b/libs/dgl/src/Geometry.cpp index e3a893d..3f90858 100644 --- a/libs/dgl/src/Geometry.cpp +++ b/libs/dgl/src/Geometry.cpp @@ -16,6 +16,8 @@ #include "../Geometry.hpp" +#include <cmath> + START_NAMESPACE_DGL // ----------------------------------------------------------------------- @@ -24,57 +26,65 @@ START_NAMESPACE_DGL template<typename T> Point<T>::Point() noexcept : fX(0), - fY(0) -{ -} + fY(0) {} template<typename T> -Point<T>::Point(T x, T y) noexcept +Point<T>::Point(const T& x, const T& y) noexcept : fX(x), - fY(y) -{ -} + fY(y) {} template<typename T> -Point<T>::Point(const Point& pos) noexcept +Point<T>::Point(const Point<T>& pos) noexcept : fX(pos.fX), - fY(pos.fY) -{ -} + fY(pos.fY) {} template<typename T> -T Point<T>::getX() const noexcept +const T& Point<T>::getX() const noexcept { return fX; } template<typename T> -T Point<T>::getY() const noexcept +const T& Point<T>::getY() const noexcept { return fY; } template<typename T> -void Point<T>::setX(T x) noexcept +void Point<T>::setX(const T& x) noexcept { fX = x; } template<typename T> -void Point<T>::setY(T y) noexcept +void Point<T>::setY(const T& y) noexcept { fY = y; } template<typename T> -void Point<T>::move(T x, T y) noexcept +void Point<T>::setPos(const T& x, const T& y) noexcept +{ + fX = x; + fY = y; +} + +template<typename T> +void Point<T>::setPos(const Point<T>& pos) noexcept +{ + fX = pos.fX; + fY = pos.fY; +} + +template<typename T> +void Point<T>::moveBy(const T& x, const T& y) noexcept { fX += x; fY += y; } template<typename T> -void Point<T>::move(const Point& pos) noexcept +void Point<T>::moveBy(const Point<T>& pos) noexcept { fX += pos.fX; fY += pos.fY; @@ -122,49 +132,71 @@ bool Point<T>::operator!=(const Point<T>& pos) const noexcept template<typename T> Size<T>::Size() noexcept : fWidth(0), - fHeight(0) -{ -} + fHeight(0) {} template<typename T> -Size<T>::Size(T width, T height) noexcept +Size<T>::Size(const T& width, const T& height) noexcept : fWidth(width), - fHeight(height) -{ -} + fHeight(height) {} template<typename T> Size<T>::Size(const Size<T>& size) noexcept : fWidth(size.fWidth), - fHeight(size.fHeight) -{ -} + fHeight(size.fHeight) {} template<typename T> -T Size<T>::getWidth() const noexcept +const T& Size<T>::getWidth() const noexcept { return fWidth; } template<typename T> -T Size<T>::getHeight() const noexcept +const T& Size<T>::getHeight() const noexcept { return fHeight; } template<typename T> -void Size<T>::setWidth(T width) noexcept +void Size<T>::setWidth(const T& width) noexcept { fWidth = width; } template<typename T> -void Size<T>::setHeight(T height) noexcept +void Size<T>::setHeight(const T& height) noexcept +{ + fHeight = height; +} + +template<typename T> +void Size<T>::setSize(const T& width, const T& height) noexcept { + fWidth = width; fHeight = height; } template<typename T> +void Size<T>::setSize(const Size<T>& size) noexcept +{ + fWidth = size.fWidth; + fHeight = size.fHeight; +} + +template<typename T> +void Size<T>::growBy(const T& multiplier) noexcept +{ + fWidth *= multiplier; + fHeight *= multiplier; +} + +template<typename T> +void Size<T>::shrinkBy(const T& divider) noexcept +{ + fWidth /= divider; + fHeight /= divider; +} + +template<typename T> Size<T>& Size<T>::operator=(const Size<T>& size) noexcept { fWidth = size.fWidth; @@ -189,7 +221,7 @@ Size<T>& Size<T>::operator-=(const Size<T>& size) noexcept } template<typename T> -Size<T>& Size<T>::operator*=(T m) noexcept +Size<T>& Size<T>::operator*=(const T& m) noexcept { fWidth *= m; fHeight *= m; @@ -197,7 +229,7 @@ Size<T>& Size<T>::operator*=(T m) noexcept } template<typename T> -Size<T>& Size<T>::operator/=(T d) noexcept +Size<T>& Size<T>::operator/=(const T& d) noexcept { fWidth /= d; fHeight /= d; @@ -217,124 +249,510 @@ bool Size<T>::operator!=(const Size<T>& size) const noexcept } // ----------------------------------------------------------------------- -// Rectangle +// Line template<typename T> -Rectangle<T>::Rectangle() noexcept - : fPos(0, 0), - fSize(0, 0) +Line<T>::Line() noexcept + : fPosStart(0, 0), + fPosEnd(0, 0) {} + +template<typename T> +Line<T>::Line(const T& startX, const T& startY, const T& endX, const T& endY) noexcept + : fPosStart(startX, startY), + fPosEnd(endX, endY) {} + +template<typename T> +Line<T>::Line(const T& startX, const T& startY, const Point<T>& endPos) noexcept + : fPosStart(startX, startY), + fPosEnd(endPos) {} + +template<typename T> +Line<T>::Line(const Point<T>& startPos, const T& endX, const T& endY) noexcept + : fPosStart(startPos), + fPosEnd(endX, endY) {} + +template<typename T> +Line<T>::Line(const Point<T>& startPos, const Point<T>& endPos) noexcept + : fPosStart(startPos), + fPosEnd(endPos) {} + +template<typename T> +Line<T>::Line(const Line<T>& line) noexcept + : fPosStart(line.fPosStart), + fPosEnd(line.fPosEnd) {} + +template<typename T> +const T& Line<T>::getStartX() const noexcept { + return fPosStart.fX; } template<typename T> -Rectangle<T>::Rectangle(T x, T y, T width, T height) noexcept - : fPos(x, y), - fSize(width, height) +const T& Line<T>::getStartY() const noexcept +{ + return fPosStart.fY; +} + +template<typename T> +const T& Line<T>::getEndX() const noexcept +{ + return fPosEnd.fX; +} + +template<typename T> +const T& Line<T>::getEndY() const noexcept +{ + return fPosEnd.fY; +} + +template<typename T> +const Point<T>& Line<T>::getStartPos() const noexcept +{ + return fPosStart; +} + +template<typename T> +const Point<T>& Line<T>::getEndPos() const noexcept +{ + return fPosEnd; +} + +template<typename T> +void Line<T>::setStartX(const T& x) noexcept +{ + fPosStart.fX = x; +} + +template<typename T> +void Line<T>::setStartY(const T& y) noexcept +{ + fPosStart.fY = y; +} + +template<typename T> +void Line<T>::setStartPos(const T& x, const T& y) noexcept +{ + fPosStart = Point<T>(x, y); +} + +template<typename T> +void Line<T>::setStartPos(const Point<T>& pos) noexcept { + fPosStart = pos; } template<typename T> -Rectangle<T>::Rectangle(T x, T y, const Size<T>& size) noexcept +void Line<T>::setEndX(const T& x) noexcept +{ + fPosEnd.fX = x; +} + +template<typename T> +void Line<T>::setEndY(const T& y) noexcept +{ + fPosEnd.fY = y; +} + +template<typename T> +void Line<T>::setEndPos(const T& x, const T& y) noexcept +{ + fPosEnd = Point<T>(x, y); +} + +template<typename T> +void Line<T>::setEndPos(const Point<T>& pos) noexcept +{ + fPosEnd = pos; +} + +template<typename T> +void Line<T>::moveBy(const T& x, const T& y) noexcept +{ + fPosStart.fX += x; + fPosStart.fY += y; + fPosEnd.fX += x; + fPosEnd.fY += y; +} + +template<typename T> +void Line<T>::moveBy(const Point<T>& pos) noexcept +{ + fPosStart += pos; + fPosEnd += pos; +} + +template<typename T> +void Line<T>::draw() +{ + glBegin(GL_LINES); + + { + glVertex2i(fPosStart.fX, fPosStart.fY); + glVertex2i(fPosEnd.fX, fPosEnd.fY); + } + + glEnd(); +} + +template<typename T> +Line<T>& Line<T>::operator=(const Line<T>& line) noexcept +{ + fPosStart = line.fPosStart; + fPosEnd = line.fPosEnd; + return *this; +} + +template<typename T> +bool Line<T>::operator==(const Line<T>& line) const noexcept +{ + return (fPosStart == line.fPosStart && fPosEnd == line.fPosEnd); +} + +template<typename T> +bool Line<T>::operator!=(const Line<T>& line) const noexcept +{ + return !operator==(line); +} + +// ----------------------------------------------------------------------- +// Circle + +template<typename T> +Circle<T>::Circle() noexcept + : fPos(0, 0), + fSize(0.0f), + fNumSegments(0), + fTheta(0.0f), + fCos(0.0f), + fSin(0.0f) +{ +} + +template<typename T> +Circle<T>::Circle(const T& x, const T& y, float size, int numSegments) : fPos(x, y), - fSize(size) + fSize(size), + fNumSegments(numSegments >= 3 ? numSegments : 3), + fTheta(2.0f * M_PI / float(fNumSegments)), + fCos(std::cos(fTheta)), + fSin(std::sin(fTheta)) { + DISTRHO_SAFE_ASSERT(fSize > 0.0f); } template<typename T> -Rectangle<T>::Rectangle(const Point<T>& pos, T width, T height) noexcept +Circle<T>::Circle(const Point<T>& pos, float size, int numSegments) : fPos(pos), - fSize(width, height) + fSize(size), + fNumSegments(numSegments >= 3 ? numSegments : 3), + fTheta(2.0f * M_PI / float(fNumSegments)), + fCos(std::cos(fTheta)), + fSin(std::sin(fTheta)) { + DISTRHO_SAFE_ASSERT(fSize > 0.0f); } template<typename T> -Rectangle<T>::Rectangle(const Point<T>& pos, const Size<T>& size) noexcept - : fPos(pos), - fSize(size) +Circle<T>::Circle(const Circle<T>& cir) noexcept + : fPos(cir.fPos), + fSize(cir.fSize), + fNumSegments(cir.fNumSegments), + fTheta(cir.fTheta), + fCos(cir.fCos), + fSin(cir.fSin) { + DISTRHO_SAFE_ASSERT(fSize > 0.0f); } template<typename T> -Rectangle<T>::Rectangle(const Rectangle<T>& rect) noexcept - : fPos(rect.fPos), - fSize(rect.fSize) +const T& Circle<T>::getX() const noexcept { + return fPos.fX; } template<typename T> -T Rectangle<T>::getX() const noexcept +const T& Circle<T>::getY() const noexcept { return fPos.fX; } template<typename T> -T Rectangle<T>::getY() const noexcept +const Point<T>& Circle<T>::getPos() const noexcept { - return fPos.fY; + return fPos; } template<typename T> -T Rectangle<T>::getWidth() const noexcept +void Circle<T>::setX(const T& x) noexcept { - return fSize.fWidth; + fPos.fX = x; } template<typename T> -T Rectangle<T>::getHeight() const noexcept +void Circle<T>::setY(const T& y) noexcept { - return fSize.fHeight; + fPos.fY = y; } template<typename T> -const Point<T>& Rectangle<T>::getPos() const noexcept +void Circle<T>::setPos(const T& x, const T& y) noexcept { - return fPos; + fPos.fX = x; + fPos.fY = y; } template<typename T> -const Size<T>& Rectangle<T>::getSize() const noexcept +void Circle<T>::setPos(const Point<T>& pos) noexcept +{ + fPos = pos; +} + +template<typename T> +float Circle<T>::getSize() const noexcept { return fSize; } template<typename T> -bool Rectangle<T>::contains(T x, T y) const noexcept +void Circle<T>::setSize(float size) noexcept { - return (x >= fPos.fX && y >= fPos.fY && x <= fPos.fX+fSize.fWidth && y <= fPos.fY+fSize.fHeight); + fSize = size; } template<typename T> -bool Rectangle<T>::contains(const Point<T>& pos) const noexcept +int Circle<T>::getNumSegments() const noexcept { - return contains(pos.fX, pos.fY); + return fNumSegments; } template<typename T> -bool Rectangle<T>::containsX(T x) const noexcept +void Circle<T>::setNumSegments(int num) { - return (x >= fPos.fX && x <= fPos.fX + fSize.fWidth); + if (fNumSegments == num) + return; + + fNumSegments = num; + + fTheta = 2.0f * M_PI / float(fNumSegments); + fCos = std::cos(fTheta); + fSin = std::sin(fTheta); } template<typename T> -bool Rectangle<T>::containsY(T y) const noexcept +void Circle<T>::draw() { - return (y >= fPos.fY && y <= fPos.fY + fSize.fHeight); + _draw(false); +} + +template<typename T> +void Circle<T>::drawOutline() +{ + _draw(true); +} + +template<typename T> +Circle<T>& Circle<T>::operator=(const Circle<T>& cir) noexcept +{ + fPos = cir.fPos; + fSize = cir.fSize; + fTheta = cir.fTheta; + fCos = cir.fCos; + fSin = cir.fSin; + fNumSegments = cir.fNumSegments; + return *this; +} + +template<typename T> +bool Circle<T>::operator==(const Circle<T>& cir) const noexcept +{ + return (fPos == cir.fPos && fSize == cir.fSize && fNumSegments == cir.fNumSegments); +} + +template<typename T> +bool Circle<T>::operator!=(const Circle<T>& cir) const noexcept +{ + return !operator==(cir); +} + +template<typename T> +void Circle<T>::_draw(const bool isOutline) +{ + if (fNumSegments == 0 && fSize > 0.0f) + return; + + float t, x = fSize, y = 0; + + glBegin(isOutline ? GL_LINE_LOOP : GL_POLYGON); + + for (int i=0; i<fNumSegments; ++i) + { + glVertex2f(x + fPos.fX, y + fPos.fY); + + t = x; + x = fCos * x - fSin * y; + y = fSin * t + fCos * y; + } + + glEnd(); +} + +// ----------------------------------------------------------------------- +// Triangle + +template<typename T> +Triangle<T>::Triangle() noexcept + : fPos1(0, 0), + fPos2(0, 0), + fPos3(0, 0) {} + +template<typename T> +Triangle<T>::Triangle(const T& x1, const T& y1, const T& x2, const T& y2, const T& x3, const T& y3) noexcept + : fPos1(x1, y1), + fPos2(x2, y2), + fPos3(x3, y3) {} + +template<typename T> +Triangle<T>::Triangle(const Point<T>& pos1, const Point<T>& pos2, const Point<T>& pos3) noexcept + : fPos1(pos1), + fPos2(pos2), + fPos3(pos3) {} + +template<typename T> +Triangle<T>::Triangle(const Triangle<T>& tri) noexcept + : fPos1(tri.fPos1), + fPos2(tri.fPos2), + fPos3(tri.fPos3) {} + +template<typename T> +void Triangle<T>::draw() +{ + _draw(false); +} + +template<typename T> +void Triangle<T>::drawOutline() +{ + _draw(true); +} + +template<typename T> +Triangle<T>& Triangle<T>::operator=(const Triangle<T>& tri) noexcept +{ + fPos1 = tri.fPos1; + fPos2 = tri.fPos2; + fPos3 = tri.fPos3; + return *this; +} + +template<typename T> +bool Triangle<T>::operator==(const Triangle<T>& tri) const noexcept +{ + return (fPos1 == tri.fPos1 && fPos2 == tri.fPos2 && fPos3 == tri.fPos3); +} + +template<typename T> +bool Triangle<T>::operator!=(const Triangle<T>& tri) const noexcept +{ + return !operator==(tri); +} + +template<typename T> +void Triangle<T>::_draw(const bool isOutline) +{ + glBegin(isOutline ? GL_LINE_LOOP : GL_TRIANGLES); + + { + glVertex2i(fPos1.fX, fPos1.fY); + glVertex2i(fPos2.fX, fPos2.fY); + glVertex2i(fPos3.fX, fPos3.fY); + } + + glEnd(); +} + +// ----------------------------------------------------------------------- +// Rectangle + +template<typename T> +Rectangle<T>::Rectangle() noexcept + : fPos(0, 0), + fSize(0, 0) {} + +template<typename T> +Rectangle<T>::Rectangle(const T& x, const T& y, const T& width, const T& height) noexcept + : fPos(x, y), + fSize(width, height) {} + +template<typename T> +Rectangle<T>::Rectangle(const T& x, const T& y, const Size<T>& size) noexcept + : fPos(x, y), + fSize(size) {} + +template<typename T> +Rectangle<T>::Rectangle(const Point<T>& pos, const T& width, const T& height) noexcept + : fPos(pos), + fSize(width, height) {} + +template<typename T> +Rectangle<T>::Rectangle(const Point<T>& pos, const Size<T>& size) noexcept + : fPos(pos), + fSize(size) {} + +template<typename T> +Rectangle<T>::Rectangle(const Rectangle<T>& rect) noexcept + : fPos(rect.fPos), + fSize(rect.fSize) {} + +template<typename T> +const T& Rectangle<T>::getX() const noexcept +{ + return fPos.fX; } template<typename T> -void Rectangle<T>::setX(T x) noexcept +const T& Rectangle<T>::getY() const noexcept +{ + return fPos.fY; +} + +template<typename T> +const T& Rectangle<T>::getWidth() const noexcept +{ + return fSize.fWidth; +} + +template<typename T> +const T& Rectangle<T>::getHeight() const noexcept +{ + return fSize.fHeight; +} + +template<typename T> +const Point<T>& Rectangle<T>::getPos() const noexcept +{ + return fPos; +} + +template<typename T> +const Size<T>& Rectangle<T>::getSize() const noexcept +{ + return fSize; +} + +template<typename T> +void Rectangle<T>::setX(const T& x) noexcept { fPos.fX = x; } template<typename T> -void Rectangle<T>::setY(T y) noexcept +void Rectangle<T>::setY(const T& y) noexcept { fPos.fY = y; } template<typename T> -void Rectangle<T>::setPos(T x, T y) noexcept +void Rectangle<T>::setPos(const T& x, const T& y) noexcept { fPos.fX = x; fPos.fY = y; @@ -347,32 +765,32 @@ void Rectangle<T>::setPos(const Point<T>& pos) noexcept } template<typename T> -void Rectangle<T>::move(T x, T y) noexcept +void Rectangle<T>::moveBy(const T& x, const T& y) noexcept { fPos.fX += x; fPos.fY += y; } template<typename T> -void Rectangle<T>::move(const Point<T>& pos) noexcept +void Rectangle<T>::moveBy(const Point<T>& pos) noexcept { fPos += pos; } template<typename T> -void Rectangle<T>::setWidth(T width) noexcept +void Rectangle<T>::setWidth(const T& width) noexcept { fSize.fWidth = width; } template<typename T> -void Rectangle<T>::setHeight(T height) noexcept +void Rectangle<T>::setHeight(const T& height) noexcept { fSize.fHeight = height; } template<typename T> -void Rectangle<T>::setSize(T width, T height) noexcept +void Rectangle<T>::setSize(const T& width, const T& height) noexcept { fSize.fWidth = width; fSize.fHeight = height; @@ -385,6 +803,56 @@ void Rectangle<T>::setSize(const Size<T>& size) noexcept } template<typename T> +void Rectangle<T>::growBy(const T& multiplier) noexcept +{ + fSize.fWidth *= multiplier; + fSize.fHeight *= multiplier; +} + +template<typename T> +void Rectangle<T>::shrinkBy(const T& divider) noexcept +{ + fSize.fWidth /= divider; + fSize.fHeight /= divider; +} + +template<typename T> +bool Rectangle<T>::contains(const T& x, const T& y) const noexcept +{ + return (x >= fPos.fX && y >= fPos.fY && x <= fPos.fX+fSize.fWidth && y <= fPos.fY+fSize.fHeight); +} + +template<typename T> +bool Rectangle<T>::contains(const Point<T>& pos) const noexcept +{ + return contains(pos.fX, pos.fY); +} + +template<typename T> +bool Rectangle<T>::containsX(const T& x) const noexcept +{ + return (x >= fPos.fX && x <= fPos.fX + fSize.fWidth); +} + +template<typename T> +bool Rectangle<T>::containsY(const T& y) const noexcept +{ + return (y >= fPos.fY && y <= fPos.fY + fSize.fHeight); +} + +template<typename T> +void Rectangle<T>::draw() +{ + _draw(false); +} + +template<typename T> +void Rectangle<T>::drawOutline() +{ + _draw(true); +} + +template<typename T> Rectangle<T>& Rectangle<T>::operator=(const Rectangle<T>& rect) noexcept { fPos = rect.fPos; @@ -392,23 +860,100 @@ Rectangle<T>& Rectangle<T>::operator=(const Rectangle<T>& rect) noexcept return *this; } +template<typename T> +Rectangle<T>& Rectangle<T>::operator*=(const T& m) noexcept +{ + fSize.fWidth *= m; + fSize.fHeight *= m; + return *this; +} + +template<typename T> +Rectangle<T>& Rectangle<T>::operator/=(const T& d) noexcept +{ + fSize.fWidth /= d; + fSize.fHeight /= d; + return *this; +} + +template<typename T> +bool Rectangle<T>::operator==(const Rectangle<T>& rect) const noexcept +{ + return (fPos == rect.fPos && fSize == rect.fSize); +} + +template<typename T> +bool Rectangle<T>::operator!=(const Rectangle<T>& rect) const noexcept +{ + return !operator==(rect); +} + +template<typename T> +void Rectangle<T>::_draw(const bool isOutline) +{ + glBegin(isOutline ? GL_LINE_LOOP : GL_QUADS); + + { + glTexCoord2f(0.0f, 0.0f); + glVertex2i(fPos.fX, fPos.fY); + + glTexCoord2f(1.0f, 0.0f); + glVertex2i(fPos.fX+fSize.fWidth, fPos.fY); + + glTexCoord2f(1.0f, 1.0f); + glVertex2i(fPos.fX+fSize.fWidth, fPos.fY+fSize.fHeight); + + glTexCoord2f(0.0f, 1.0f); + glVertex2i(fPos.fX, fPos.fY+fSize.fHeight); + } + + glEnd(); +} + // ----------------------------------------------------------------------- // Possible template data types -template class Point<int>; -template class Point<long>; -template class Point<float>; template class Point<double>; +template class Point<float>; +template class Point<int>; +template class Point<uint>; +template class Point<short>; +template class Point<ushort>; -template class Size<int>; -template class Size<long>; -template class Size<float>; template class Size<double>; +template class Size<float>; +template class Size<int>; +template class Size<uint>; +template class Size<short>; +template class Size<ushort>; + +template class Line<double>; +template class Line<float>; +template class Line<int>; +template class Line<uint>; +template class Line<short>; +template class Line<ushort>; + +template class Circle<double>; +template class Circle<float>; +template class Circle<int>; +template class Circle<uint>; +template class Circle<short>; +template class Circle<ushort>; + +template class Triangle<double>; +template class Triangle<float>; +template class Triangle<int>; +template class Triangle<uint>; +template class Triangle<short>; +template class Triangle<ushort>; -template class Rectangle<int>; -template class Rectangle<long>; -template class Rectangle<float>; template class Rectangle<double>; +template class Rectangle<float>; +template class Rectangle<int>; +template class Rectangle<uint>; +template class Rectangle<short>; +template class Rectangle<ushort>; // ----------------------------------------------------------------------- diff --git a/libs/dgl/src/Image.cpp b/libs/dgl/src/Image.cpp index 0fb7298..81b24dd 100644 --- a/libs/dgl/src/Image.cpp +++ b/libs/dgl/src/Image.cpp @@ -20,40 +20,48 @@ START_NAMESPACE_DGL // ----------------------------------------------------------------------- -Image::Image() noexcept +Image::Image() : fRawData(nullptr), fSize(0, 0), fFormat(0), fType(0), - fTextureId(0) + fTextureId(0), + fIsReady(false) { + glGenTextures(1, &fTextureId); } -Image::Image(const char* rawData, int width, int height, GLenum format, GLenum type) noexcept +Image::Image(const char* rawData, int width, int height, GLenum format, GLenum type) : fRawData(rawData), fSize(width, height), fFormat(format), fType(type), - fTextureId(0) + fTextureId(0), + fIsReady(false) { + glGenTextures(1, &fTextureId); } -Image::Image(const char* rawData, const Size<int>& size, GLenum format, GLenum type) noexcept +Image::Image(const char* rawData, const Size<int>& size, GLenum format, GLenum type) : fRawData(rawData), fSize(size), fFormat(format), fType(type), - fTextureId(0) + fTextureId(0), + fIsReady(false) { + glGenTextures(1, &fTextureId); } -Image::Image(const Image& image) noexcept +Image::Image(const Image& image) : fRawData(image.fRawData), fSize(image.fSize), fFormat(image.fFormat), fType(image.fType), - fTextureId(0) + fTextureId(0), + fIsReady(false) { + glGenTextures(1, &fTextureId); } Image::~Image() @@ -76,11 +84,12 @@ void Image::loadFromMemory(const char* rawData, const Size<int>& size, GLenum fo fSize = size; fFormat = format; fType = type; + fIsReady = false; } bool Image::isValid() const noexcept { - return (fRawData != nullptr && getWidth() > 0 && getHeight() > 0); + return (fRawData != nullptr && fSize.getWidth() > 0 && fSize.getHeight() > 0); } int Image::getWidth() const noexcept @@ -115,63 +124,45 @@ GLenum Image::getType() const noexcept void Image::draw() { - draw(0, 0); + drawAt(0, 0); } -void Image::draw(int x, int y) +void Image::drawAt(int x, int y) { - if (! isValid()) - return; - if (fTextureId == 0) - glGenTextures(1, &fTextureId); - if (fTextureId == 0) - { - // invalidate image - fSize = Size<int>(0, 0); + drawAt(Point<int>(x, y)); +} + +void Image::drawAt(const Point<int>& pos) +{ + if (fTextureId == 0 || ! isValid()) return; - } glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, fTextureId); - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - glPixelStorei(GL_PACK_ALIGNMENT, 1); - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, getWidth(), getHeight(), 0, fFormat, fType, fRawData); - - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); - - float trans[] = { 0.0f, 0.0f, 0.0f, 0.0f }; - glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, trans); - - const int width = getWidth(); - const int height = getHeight(); + if (! fIsReady) + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); - glBegin(GL_QUADS); - glTexCoord2f(0.0f, 0.0f); - glVertex2i(x, y); + static const float trans[] = { 0.0f, 0.0f, 0.0f, 0.0f }; + glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, trans); - glTexCoord2f(1.0f, 0.0f); - glVertex2i(x+width, y); + glPixelStorei(GL_PACK_ALIGNMENT, 1); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, fSize.getWidth(), fSize.getHeight(), 0, fFormat, fType, fRawData); - glTexCoord2f(1.0f, 1.0f); - glVertex2i(x+width, y+height); + fIsReady = true; + } - glTexCoord2f(0.0f, 1.0f); - glVertex2i(x, y+height); - glEnd(); + Rectangle<int>(pos, fSize).draw(); glBindTexture(GL_TEXTURE_2D, 0); glDisable(GL_TEXTURE_2D); } -void Image::draw(const Point<int>& pos) -{ - draw(pos.getX(), pos.getY()); -} - // ----------------------------------------------------------------------- Image& Image::operator=(const Image& image) noexcept @@ -180,17 +171,18 @@ Image& Image::operator=(const Image& image) noexcept fSize = image.fSize; fFormat = image.fFormat; fType = image.fType; + fIsReady = false; return *this; } bool Image::operator==(const Image& image) const noexcept { - return (fRawData == image.fRawData); + return (fRawData == image.fRawData && fSize == image.fSize); } bool Image::operator!=(const Image& image) const noexcept { - return (fRawData != image.fRawData); + return !operator==(image); } // ----------------------------------------------------------------------- diff --git a/libs/dgl/src/ImageAboutWindow.cpp b/libs/dgl/src/ImageAboutWindow.cpp index 67b2886..8d414d3 100644 --- a/libs/dgl/src/ImageAboutWindow.cpp +++ b/libs/dgl/src/ImageAboutWindow.cpp @@ -20,13 +20,13 @@ START_NAMESPACE_DGL // ----------------------------------------------------------------------- -ImageAboutWindow::ImageAboutWindow(App& app, Window& parent, const Image& image) - : Window(app, parent), +ImageAboutWindow::ImageAboutWindow(Window& parent, const Image& image) + : Window(parent.getApp(), parent), Widget((Window&)*this), fImgBackground(image) { Window::setResizable(false); - Window::setSize(static_cast<unsigned int>(image.getWidth()), static_cast<unsigned int>(image.getHeight())); + Window::setSize(static_cast<uint>(image.getWidth()), static_cast<uint>(image.getHeight())); Window::setTitle("About"); } @@ -36,14 +36,17 @@ ImageAboutWindow::ImageAboutWindow(Widget* widget, const Image& image) fImgBackground(image) { Window::setResizable(false); - Window::setSize(static_cast<unsigned int>(image.getWidth()), static_cast<unsigned int>(image.getHeight())); + Window::setSize(static_cast<uint>(image.getWidth()), static_cast<uint>(image.getHeight())); Window::setTitle("About"); } void ImageAboutWindow::setImage(const Image& image) { + if (fImgBackground == image) + return; + fImgBackground = image; - Window::setSize(static_cast<unsigned int>(image.getWidth()), static_cast<unsigned int>(image.getHeight())); + Window::setSize(static_cast<uint>(image.getWidth()), static_cast<uint>(image.getHeight())); } void ImageAboutWindow::onDisplay() @@ -51,9 +54,9 @@ void ImageAboutWindow::onDisplay() fImgBackground.draw(); } -bool ImageAboutWindow::onMouse(int, bool press, int, int) +bool ImageAboutWindow::onKeyboard(const KeyboardEvent& ev) { - if (press) + if (ev.press && ev.key == CHAR_ESCAPE) { Window::close(); return true; @@ -62,9 +65,9 @@ bool ImageAboutWindow::onMouse(int, bool press, int, int) return false; } -bool ImageAboutWindow::onKeyboard(bool press, uint32_t key) +bool ImageAboutWindow::onMouse(const MouseEvent& ev) { - if (press && key == CHAR_ESCAPE) + if (ev.press) { Window::close(); return true; @@ -73,6 +76,12 @@ bool ImageAboutWindow::onKeyboard(bool press, uint32_t key) return false; } +void ImageAboutWindow::onReshape(int width, int height) +{ + Widget::setSize(width, height); + Window::onReshape(width, height); +} + // ----------------------------------------------------------------------- END_NAMESPACE_DGL diff --git a/libs/dgl/src/ImageButton.cpp b/libs/dgl/src/ImageButton.cpp index 01ca424..29f27bd 100644 --- a/libs/dgl/src/ImageButton.cpp +++ b/libs/dgl/src/ImageButton.cpp @@ -16,13 +16,11 @@ #include "../ImageButton.hpp" -#include <cassert> - START_NAMESPACE_DGL // ----------------------------------------------------------------------- -ImageButton::ImageButton(Window& parent, const Image& image) +ImageButton::ImageButton(Window& parent, const Image& image) noexcept : Widget(parent), fImageNormal(image), fImageHover(image), @@ -33,18 +31,7 @@ ImageButton::ImageButton(Window& parent, const Image& image) { } -ImageButton::ImageButton(Widget* widget, const Image& image) - : Widget(widget->getParentWindow()), - fImageNormal(image), - fImageHover(image), - fImageDown(image), - fCurImage(&fImageNormal), - fCurButton(-1), - fCallback(nullptr) -{ -} - -ImageButton::ImageButton(Window& parent, const Image& imageNormal, const Image& imageHover, const Image& imageDown) +ImageButton::ImageButton(Window& parent, const Image& imageNormal, const Image& imageHover, const Image& imageDown) noexcept : Widget(parent), fImageNormal(imageNormal), fImageHover(imageHover), @@ -53,12 +40,23 @@ ImageButton::ImageButton(Window& parent, const Image& imageNormal, const Image& fCurButton(-1), fCallback(nullptr) { - assert(fImageNormal.getSize() == fImageHover.getSize() && fImageHover.getSize() == fImageDown.getSize()); + DISTRHO_SAFE_ASSERT(fImageNormal.getSize() == fImageHover.getSize() && fImageHover.getSize() == fImageDown.getSize()); setSize(fCurImage->getSize()); } -ImageButton::ImageButton(Widget* widget, const Image& imageNormal, const Image& imageHover, const Image& imageDown) +ImageButton::ImageButton(Widget* widget, const Image& image) noexcept + : Widget(widget->getParentWindow()), + fImageNormal(image), + fImageHover(image), + fImageDown(image), + fCurImage(&fImageNormal), + fCurButton(-1), + fCallback(nullptr) +{ +} + +ImageButton::ImageButton(Widget* widget, const Image& imageNormal, const Image& imageHover, const Image& imageDown) noexcept : Widget(widget->getParentWindow()), fImageNormal(imageNormal), fImageHover(imageHover), @@ -67,12 +65,12 @@ ImageButton::ImageButton(Widget* widget, const Image& imageNormal, const Image& fCurButton(-1), fCallback(nullptr) { - assert(fImageNormal.getSize() == fImageHover.getSize() && fImageHover.getSize() == fImageDown.getSize()); + DISTRHO_SAFE_ASSERT(fImageNormal.getSize() == fImageHover.getSize() && fImageHover.getSize() == fImageDown.getSize()); setSize(fCurImage->getSize()); } -ImageButton::ImageButton(const ImageButton& imageButton) +ImageButton::ImageButton(const ImageButton& imageButton) noexcept : Widget(imageButton.getParentWindow()), fImageNormal(imageButton.fImageNormal), fImageHover(imageButton.fImageHover), @@ -81,24 +79,24 @@ ImageButton::ImageButton(const ImageButton& imageButton) fCurButton(-1), fCallback(imageButton.fCallback) { - assert(fImageNormal.getSize() == fImageHover.getSize() && fImageHover.getSize() == fImageDown.getSize()); + DISTRHO_SAFE_ASSERT(fImageNormal.getSize() == fImageHover.getSize() && fImageHover.getSize() == fImageDown.getSize()); setSize(fCurImage->getSize()); } -void ImageButton::setCallback(Callback* callback) +void ImageButton::setCallback(Callback* callback) noexcept { fCallback = callback; } void ImageButton::onDisplay() { - fCurImage->draw(getPos()); + fCurImage->draw(); } -bool ImageButton::onMouse(int button, bool press, int x, int y) +bool ImageButton::onMouse(const MouseEvent& ev) { - if (fCurButton != -1 && ! press) + if (fCurButton != -1 && ! ev.press) { if (fCurImage != &fImageNormal) { @@ -106,7 +104,7 @@ bool ImageButton::onMouse(int button, bool press, int x, int y) repaint(); } - if (! getArea().contains(x, y)) + if (! contains(ev.pos)) { fCurButton = -1; return false; @@ -115,18 +113,20 @@ bool ImageButton::onMouse(int button, bool press, int x, int y) if (fCallback != nullptr) fCallback->imageButtonClicked(this, fCurButton); - //if (getArea().contains(x, y)) - //{ - // fCurImage = &fImageHover; - // repaint(); - //} +#if 0 + if (contains(ev.pos)) + { + fCurImage = &fImageHover; + repaint(); + } +#endif fCurButton = -1; return true; } - if (press && getArea().contains(x, y)) + if (ev.press && contains(ev.pos)) { if (fCurImage != &fImageDown) { @@ -134,19 +134,19 @@ bool ImageButton::onMouse(int button, bool press, int x, int y) repaint(); } - fCurButton = button; + fCurButton = ev.button; return true; } return false; } -bool ImageButton::onMotion(int x, int y) +bool ImageButton::onMotion(const MotionEvent& ev) { if (fCurButton != -1) return true; - if (getArea().contains(x, y)) + if (contains(ev.pos)) { if (fCurImage != &fImageHover) { diff --git a/libs/dgl/src/ImageKnob.cpp b/libs/dgl/src/ImageKnob.cpp index dfb28a5..9c90406 100644 --- a/libs/dgl/src/ImageKnob.cpp +++ b/libs/dgl/src/ImageKnob.cpp @@ -17,22 +17,23 @@ #include "../ImageKnob.hpp" #include <cmath> -#include <cstdio> START_NAMESPACE_DGL // ----------------------------------------------------------------------- -ImageKnob::ImageKnob(Window& parent, const Image& image, Orientation orientation) +ImageKnob::ImageKnob(Window& parent, const Image& image, Orientation orientation, int id) noexcept : Widget(parent), fImage(image), + fId(id), fMinimum(0.0f), fMaximum(1.0f), fStep(0.0f), - fLog(false), fValue(0.5f), - fValueTmp(fValue), fValueDef(fValue), + fValueTmp(fValue), + fUsingDefault(false), + fUsingLog(false), fOrientation(orientation), fRotationAngle(0), fDragging(false), @@ -48,16 +49,18 @@ ImageKnob::ImageKnob(Window& parent, const Image& image, Orientation orientation setSize(fImgLayerSize, fImgLayerSize); } -ImageKnob::ImageKnob(Widget* widget, const Image& image, Orientation orientation) +ImageKnob::ImageKnob(Widget* widget, const Image& image, Orientation orientation, int id) noexcept : Widget(widget->getParentWindow()), fImage(image), + fId(id), fMinimum(0.0f), fMaximum(1.0f), fStep(0.0f), - fLog(false), fValue(0.5f), - fValueTmp(fValue), fValueDef(fValue), + fValueTmp(fValue), + fUsingDefault(false), + fUsingLog(false), fOrientation(orientation), fRotationAngle(0), fDragging(false), @@ -76,13 +79,15 @@ ImageKnob::ImageKnob(Widget* widget, const Image& image, Orientation orientation ImageKnob::ImageKnob(const ImageKnob& imageKnob) : Widget(imageKnob.getParentWindow()), fImage(imageKnob.fImage), + fId(imageKnob.fId), fMinimum(imageKnob.fMinimum), fMaximum(imageKnob.fMaximum), fStep(imageKnob.fStep), - fLog(imageKnob.fLog), fValue(imageKnob.fValue), + fValueDef(imageKnob.fValueDef), fValueTmp(fValue), - fValueDef(fValue), + fUsingDefault(imageKnob.fUsingDefault), + fUsingLog(imageKnob.fUsingLog), fOrientation(imageKnob.fOrientation), fRotationAngle(imageKnob.fRotationAngle), fDragging(false), @@ -105,28 +110,48 @@ ImageKnob::ImageKnob(const ImageKnob& imageKnob) } } -float ImageKnob::getValue() const +ImageKnob::~ImageKnob() { - return fValue; + // delete old texture + setRotationAngle(0); } -void ImageKnob::setOrientation(Orientation orientation) +int ImageKnob::getId() const noexcept { - if (fOrientation == orientation) - return; + return fId; +} - fOrientation = orientation; +void ImageKnob::setId(int id) noexcept +{ + fId = id;; +} + +float ImageKnob::getValue() const noexcept +{ + return fValue; +} + +void ImageKnob::setDefault(float value) noexcept +{ + fValueDef = value; + fUsingDefault = true; } -void ImageKnob::setRange(float min, float max) +void ImageKnob::setRange(float min, float max) noexcept { + DISTRHO_SAFE_ASSERT_RETURN(max > min,); + if (fValue < min) { fValue = min; repaint(); if (fCallback != nullptr) - fCallback->imageKnobValueChanged(this, fValue); + { + try { + fCallback->imageKnobValueChanged(this, fValue); + } DISTRHO_SAFE_EXCEPTION("ImageKnob::setRange < min"); + } } else if (fValue > max) { @@ -134,77 +159,58 @@ void ImageKnob::setRange(float min, float max) repaint(); if (fCallback != nullptr) - fCallback->imageKnobValueChanged(this, fValue); + { + try { + fCallback->imageKnobValueChanged(this, fValue); + } DISTRHO_SAFE_EXCEPTION("ImageKnob::setRange > max"); + } } fMinimum = min; fMaximum = max; } -void ImageKnob::setStep(float step) +void ImageKnob::setStep(float step) noexcept { fStep = step; } -void ImageKnob::setLogScale(bool yesNo) +void ImageKnob::setValue(float value, bool sendCallback) noexcept { - fLog = yesNo; -} + if (fValue == value) + return; -float ImageKnob::logscale(float value) -{ - if (fLog) { - float b = log(fMaximum/fMinimum)/(fMaximum-fMinimum); - float a = fMaximum/exp(fMaximum*b); - float logval = a * exp(b*value); - return logval; - } - return value; -} + fValue = fUsingLog ? _logscale(value) : value; -float ImageKnob::invlogscale(float value) -{ - if (fLog) { - float b = log(fMaximum/fMinimum)/(fMaximum-fMinimum); - float a = fMaximum/exp(fMaximum*b); - float logval = log(value/a)/b; - return logval; - - } - return value; + if (fStep == 0.0f) + fValueTmp = value; + + repaint(); + + if (sendCallback && fCallback != nullptr) + { + try { + fCallback->imageKnobValueChanged(this, fValue); + } DISTRHO_SAFE_EXCEPTION("ImageKnob::setValue"); + } } -void ImageKnob::setDefault(float value) +void ImageKnob::setUsingLogScale(bool yesNo) noexcept { - fValueDef = value; - fValueTmp = value; - resetDefault(); + fUsingLog = yesNo; } -void ImageKnob::resetDefault() +void ImageKnob::setCallback(Callback* callback) noexcept { - fValueTmp = invlogscale(fValueDef); - fValue = fValueDef; - repaint(); - if (fCallback != nullptr) - fCallback->imageKnobValueChanged(this, fValue); + fCallback = callback; } -void ImageKnob::setValue(float value, bool sendCallback) +void ImageKnob::setOrientation(Orientation orientation) noexcept { - if (fValue == value) + if (fOrientation == orientation) return; - fValue = logscale(value); - - if (fStep == 0.0f) { - fValueTmp = value; - } - - repaint(); - - if (sendCallback && fCallback != nullptr) - fCallback->imageKnobValueChanged(this, fValue); + fOrientation = orientation; } void ImageKnob::setRotationAngle(int angle) @@ -227,8 +233,8 @@ void ImageKnob::setRotationAngle(int angle) glGenTextures(1, &fTextureId); glBindTexture(GL_TEXTURE_2D, fTextureId); - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glPixelStorei(GL_PACK_ALIGNMENT, 1); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, getWidth(), getHeight(), 0, fImage.getFormat(), fImage.getType(), fImage.getRawData()); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); @@ -236,7 +242,7 @@ void ImageKnob::setRotationAngle(int angle) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); - float trans[] = { 0.0f, 0.0f, 0.0f, 0.0f }; + static const float trans[] = { 0.0f, 0.0f, 0.0f, 0.0f }; glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, trans); glBindTexture(GL_TEXTURE_2D, 0); @@ -244,23 +250,17 @@ void ImageKnob::setRotationAngle(int angle) } } -void ImageKnob::setCallback(Callback* callback) -{ - fCallback = callback; -} - void ImageKnob::onDisplay() { - const float normValue = (fValue - fMinimum) / (fMaximum - fMinimum); - const float logValue = (invlogscale(fValue) - fMinimum) / (fMaximum - fMinimum); + const float normValue = (fUsingLog ? _invlogscale(fValue) : fValue - fMinimum) / (fMaximum - fMinimum); if (fRotationAngle != 0) { glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, fTextureId); - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glPixelStorei(GL_PACK_ALIGNMENT, 1); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, getWidth(), getHeight(), 0, fImage.getFormat(), fImage.getType(), fImage.getRawData()); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); @@ -268,7 +268,7 @@ void ImageKnob::onDisplay() glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); - float trans[] = { 0.0f, 0.0f, 0.0f, 0.0f }; + static const float trans[] = { 0.0f, 0.0f, 0.0f, 0.0f }; glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, trans); glPushMatrix(); @@ -276,22 +276,10 @@ void ImageKnob::onDisplay() const GLint w2 = getWidth()/2; const GLint h2 = getHeight()/2; - glTranslatef(static_cast<float>(getX()+w2), static_cast<float>(getY()+h2), 0.0f); - glRotatef(logValue*static_cast<float>(fRotationAngle), 0.0f, 0.0f, 1.0f); - - glBegin(GL_QUADS); - glTexCoord2f(0.0f, 0.0f); - glVertex2i(-w2, -h2); + glTranslatef(static_cast<float>(w2), static_cast<float>(h2), 0.0f); + glRotatef(normValue*static_cast<float>(fRotationAngle), 0.0f, 0.0f, 1.0f); - glTexCoord2f(1.0f, 0.0f); - glVertex2i(getWidth()-w2, -h2); - - glTexCoord2f(1.0f, 1.0f); - glVertex2i(getWidth()-w2, getHeight()-h2); - - glTexCoord2f(0.0f, 1.0f); - glVertex2i(-w2, getHeight()-h2); - glEnd(); + Rectangle<int>(-w2, -h2, getWidth(), getHeight()).draw(); glPopMatrix(); @@ -300,66 +288,40 @@ void ImageKnob::onDisplay() } else { + // FIXME - DO NOT USE glDrawPixels! + const int layerDataSize = fImgLayerSize * fImgLayerSize * ((fImage.getFormat() == GL_BGRA || fImage.getFormat() == GL_RGBA) ? 4 : 3); const int imageDataSize = layerDataSize * fImgLayerCount; const int imageDataOffset = imageDataSize - layerDataSize - (layerDataSize * int(normValue * float(fImgLayerCount-1))); - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glPixelStorei(GL_PACK_ALIGNMENT, 1); - glRasterPos2i(getX(), getY()+getHeight()); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glRasterPos2i(0, getHeight()); + //glRasterPos2i(getX(), getY()+getHeight()); glDrawPixels(fImgLayerSize, fImgLayerSize, fImage.getFormat(), fImage.getType(), fImage.getRawData() + imageDataOffset); } } -bool ImageKnob::onScroll(int x, int y, float, float dy) -{ - float d, value; - - if (! getArea().contains(x,y)) - return false; - - d = (getModifiers() & MODIFIER_CTRL) ? 2000.0f : 200.0f; - value = (fValueTmp) + (float(fMaximum - fMinimum) / d * 10.f * dy ); - - if (value < fMinimum) - { - value = fMinimum; - fValueTmp = value; - } - else if (value > fMaximum) - { - value = fMaximum; - fValueTmp = value; - } - else if (fStep != 0.0f) - { - fValueTmp = value; - const float rest = std::fmod(value, fStep); - value = value - rest + (rest > fStep/2.0f ? fStep : 0.0f); - } - - setValue(value, true); - return true; -} - -bool ImageKnob::onMouse(int button, bool press, int x, int y) +bool ImageKnob::onMouse(const MouseEvent& ev) { - if (button != 1) + if (ev.button != 1) return false; - if (press) + if (ev.press) { - if (! getArea().contains(x, y)) + if (! contains(ev.pos)) return false; - - if (getModifiers() & MODIFIER_SHIFT) { - resetDefault(); - return false; - } + + if ((ev.mod & MODIFIER_SHIFT) != 0 && fUsingDefault) + { + setValue(fValueDef, true); + fValueTmp = fValue; + return true; + } fDragging = true; - fLastX = x; - fLastY = y; + fLastX = ev.pos.getX(); + fLastY = ev.pos.getY(); if (fCallback != nullptr) fCallback->imageKnobDragStarted(this); @@ -378,24 +340,31 @@ bool ImageKnob::onMouse(int button, bool press, int x, int y) return false; } -bool ImageKnob::onMotion(int x, int y) +bool ImageKnob::onMotion(const MotionEvent& ev) { if (! fDragging) return false; bool doVal = false; - float d, value, r, movR; - int movX, movY; - movX = x - fLastX; - movY = fLastY - y; - r = sqrt(movX*movX + movY*movY); - movR = ((movX + movY) > 0) ? r : -r; - - if (movR) + float d, value; + + if (fOrientation == ImageKnob::Horizontal) + { + if (const int movX = ev.pos.getX() - fLastX) + { + d = (ev.mod & MODIFIER_CTRL) ? 2000.0f : 200.0f; + value = fValueTmp + (float(fMaximum - fMinimum) / d * float(movX)); + doVal = true; + } + } + else if (fOrientation == ImageKnob::Vertical) { - d = (getModifiers() & MODIFIER_CTRL) ? 2000.0f : 200.0f; - value = (fValueTmp) + (float(fMaximum - fMinimum) / d * float((movR))); - doVal = true; + if (const int movY = fLastY - ev.pos.getY()) + { + d = (ev.mod & MODIFIER_CTRL) ? 2000.0f : 200.0f; + value = fValueTmp + (float(fMaximum - fMinimum) / d * float(movY)); + doVal = true; + } } if (! doVal) @@ -403,13 +372,11 @@ bool ImageKnob::onMotion(int x, int y) if (value < fMinimum) { - value = fMinimum; - fValueTmp = value; + fValueTmp = value = fMinimum; } else if (value > fMaximum) { - value = fMaximum; - fValueTmp = value; + fValueTmp = value = fMaximum; } else if (fStep != 0.0f) { @@ -420,24 +387,53 @@ bool ImageKnob::onMotion(int x, int y) setValue(value, true); - fLastX = x; - fLastY = y; + fLastX = ev.pos.getX(); + fLastY = ev.pos.getY(); return true; } -void ImageKnob::onReshape(int width, int height) +bool ImageKnob::onScroll(const ScrollEvent& ev) { -// if (fRotationAngle != 0) -// glEnable(GL_TEXTURE_2D); + if (! contains(ev.pos)) + return false; + + const float d = (ev.mod & MODIFIER_CTRL) ? 2000.0f : 200.0f; + float value = (fValueTmp) + (float(fMaximum - fMinimum) / d * 10.f * ev.delta.getY()); + + if (value < fMinimum) + { + fValueTmp = value = fMinimum; + } + else if (value > fMaximum) + { + fValueTmp = value = fMaximum; + } + else if (fStep != 0.0f) + { + fValueTmp = value; + const float rest = std::fmod(value, fStep); + value = value - rest + (rest > fStep/2.0f ? fStep : 0.0f); + } - Widget::onReshape(width, height); + setValue(value, true); + return true; } -void ImageKnob::onClose() +// ----------------------------------------------------------------------- + +float ImageKnob::_logscale(float value) const { - // delete old texture - setRotationAngle(0); + const float b = std::log(fMaximum/fMinimum)/(fMaximum-fMinimum); + const float a = fMaximum/std::exp(fMaximum*b); + return a * std::exp(b*value); +} + +float ImageKnob::_invlogscale(float value) const +{ + const float b = std::log(fMaximum/fMinimum)/(fMaximum-fMinimum); + const float a = fMaximum/std::exp(fMaximum*b); + return std::log(value/a)/b; } // ----------------------------------------------------------------------- diff --git a/libs/dgl/src/ImageSlider.cpp b/libs/dgl/src/ImageSlider.cpp index b386110..f6a9f49 100644 --- a/libs/dgl/src/ImageSlider.cpp +++ b/libs/dgl/src/ImageSlider.cpp @@ -22,9 +22,10 @@ START_NAMESPACE_DGL // ----------------------------------------------------------------------- -ImageSlider::ImageSlider(Window& parent, const Image& image) +ImageSlider::ImageSlider(Window& parent, const Image& image, int id) noexcept : Widget(parent), fImage(image), + fId(id), fMinimum(0.0f), fMaximum(1.0f), fStep(0.0f), @@ -36,12 +37,13 @@ ImageSlider::ImageSlider(Window& parent, const Image& image) fStartedY(0), fCallback(nullptr) { - setSize(fImage.getSize()); + Widget::setNeedsFullViewport(true); } -ImageSlider::ImageSlider(Widget* widget, const Image& image) +ImageSlider::ImageSlider(Widget* widget, const Image& image, int id) noexcept : Widget(widget->getParentWindow()), fImage(image), + fId(id), fMinimum(0.0f), fMaximum(1.0f), fStep(0.0f), @@ -53,12 +55,13 @@ ImageSlider::ImageSlider(Widget* widget, const Image& image) fStartedY(0), fCallback(nullptr) { - setSize(fImage.getSize()); + Widget::setNeedsFullViewport(true); } -ImageSlider::ImageSlider(const ImageSlider& imageSlider) +ImageSlider::ImageSlider(const ImageSlider& imageSlider) noexcept : Widget(imageSlider.getParentWindow()), fImage(imageSlider.fImage), + fId(imageSlider.fId), fMinimum(imageSlider.fMinimum), fMaximum(imageSlider.fMaximum), fStep(imageSlider.fStep), @@ -73,37 +76,47 @@ ImageSlider::ImageSlider(const ImageSlider& imageSlider) fEndPos(imageSlider.fEndPos), fSliderArea(imageSlider.fSliderArea) { - setSize(fImage.getSize()); + Widget::setNeedsFullViewport(true); } -float ImageSlider::getValue() const +int ImageSlider::getId() const noexcept +{ + return fId; +} + +void ImageSlider::setId(int id) noexcept +{ + fId = id; +} + +float ImageSlider::getValue() const noexcept { return fValue; } -void ImageSlider::setStartPos(const Point<int>& startPos) +void ImageSlider::setStartPos(const Point<int>& startPos) noexcept { fStartPos = startPos; _recheckArea(); } -void ImageSlider::setStartPos(int x, int y) +void ImageSlider::setStartPos(int x, int y) noexcept { setStartPos(Point<int>(x, y)); } -void ImageSlider::setEndPos(const Point<int>& endPos) +void ImageSlider::setEndPos(const Point<int>& endPos) noexcept { fEndPos = endPos; _recheckArea(); } -void ImageSlider::setEndPos(int x, int y) +void ImageSlider::setEndPos(int x, int y) noexcept { setEndPos(Point<int>(x, y)); } -void ImageSlider::setInverted(bool inverted) +void ImageSlider::setInverted(bool inverted) noexcept { if (fInverted == inverted) return; @@ -112,7 +125,7 @@ void ImageSlider::setInverted(bool inverted) repaint(); } -void ImageSlider::setRange(float min, float max) +void ImageSlider::setRange(float min, float max) noexcept { if (fValue < min) { @@ -120,7 +133,11 @@ void ImageSlider::setRange(float min, float max) repaint(); if (fCallback != nullptr) - fCallback->imageSliderValueChanged(this, fValue); + { + try { + fCallback->imageSliderValueChanged(this, fValue); + } DISTRHO_SAFE_EXCEPTION("ImageSlider::setRange < min"); + } } else if (fValue > max) { @@ -128,19 +145,23 @@ void ImageSlider::setRange(float min, float max) repaint(); if (fCallback != nullptr) - fCallback->imageSliderValueChanged(this, fValue); + { + try { + fCallback->imageSliderValueChanged(this, fValue); + } DISTRHO_SAFE_EXCEPTION("ImageSlider::setRange > max"); + } } fMinimum = min; fMaximum = max; } -void ImageSlider::setStep(float step) +void ImageSlider::setStep(float step) noexcept { fStep = step; } -void ImageSlider::setValue(float value, bool sendCallback) +void ImageSlider::setValue(float value, bool sendCallback) noexcept { if (fValue == value) return; @@ -153,10 +174,14 @@ void ImageSlider::setValue(float value, bool sendCallback) repaint(); if (sendCallback && fCallback != nullptr) - fCallback->imageSliderValueChanged(this, fValue); + { + try { + fCallback->imageSliderValueChanged(this, fValue); + } DISTRHO_SAFE_EXCEPTION("ImageSlider::setValue"); + } } -void ImageSlider::setCallback(Callback* callback) +void ImageSlider::setCallback(Callback* callback) noexcept { fCallback = callback; } @@ -194,20 +219,22 @@ void ImageSlider::onDisplay() y = fStartPos.getY() + static_cast<int>(normValue*static_cast<float>(fEndPos.getY()-fStartPos.getY())); } - fImage.draw(x, y); + fImage.drawAt(x, y); } -bool ImageSlider::onMouse(int button, bool press, int x, int y) +bool ImageSlider::onMouse(const MouseEvent& ev) { - if (button != 1) + if (ev.button != 1) return false; - if (press) + if (ev.press) { - if (! fSliderArea.contains(x, y)) + if (! fSliderArea.contains(ev.pos)) return false; float vper; + const int x = ev.pos.getX(); + const int y = ev.pos.getY(); if (fStartPos.getY() == fEndPos.getY()) { @@ -229,13 +256,11 @@ bool ImageSlider::onMouse(int button, bool press, int x, int y) if (value < fMinimum) { - value = fMinimum; - fValueTmp = value; + fValueTmp = value = fMinimum; } else if (value > fMaximum) { - value = fMaximum; - fValueTmp = value; + fValueTmp = value = fMaximum; } else if (fStep != 0.0f) { @@ -267,12 +292,14 @@ bool ImageSlider::onMouse(int button, bool press, int x, int y) return false; } -bool ImageSlider::onMotion(int x, int y) +bool ImageSlider::onMotion(const MotionEvent& ev) { if (! fDragging) return false; const bool horizontal = fStartPos.getY() == fEndPos.getY(); + const int x = ev.pos.getX(); + const int y = ev.pos.getY(); if ((horizontal && fSliderArea.containsX(x)) || (fSliderArea.containsY(y) && ! horizontal)) { @@ -298,13 +325,11 @@ bool ImageSlider::onMotion(int x, int y) if (value < fMinimum) { - value = fMinimum; - fValueTmp = value; + fValueTmp = value = fMinimum; } else if (value > fMaximum) { - value = fMaximum; - fValueTmp = value; + fValueTmp = value = fMaximum; } else if (fStep != 0.0f) { @@ -333,7 +358,7 @@ bool ImageSlider::onMotion(int x, int y) return true; } -void ImageSlider::_recheckArea() +void ImageSlider::_recheckArea() noexcept { if (fStartPos.getY() == fEndPos.getY()) { diff --git a/libs/dgl/src/ImageSwitch.cpp b/libs/dgl/src/ImageSwitch.cpp new file mode 100644 index 0000000..41492b5 --- /dev/null +++ b/libs/dgl/src/ImageSwitch.cpp @@ -0,0 +1,118 @@ +/* + * DISTRHO Plugin Framework (DPF) + * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com> + * + * Permission to use, copy, modify, and/or distribute this software for any purpose with + * or without fee is hereby granted, provided that the above copyright notice and this + * permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD + * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN + * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER + * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "../ImageSwitch.hpp" + +START_NAMESPACE_DGL + +// ----------------------------------------------------------------------- + +ImageSwitch::ImageSwitch(Window& parent, const Image& imageNormal, const Image& imageDown, int id) noexcept + : Widget(parent), + fImageNormal(imageNormal), + fImageDown(imageDown), + fIsDown(false), + fId(id), + fCallback(nullptr) +{ + DISTRHO_SAFE_ASSERT(fImageNormal.getSize() == fImageDown.getSize()); + + setSize(fImageNormal.getSize()); +} + +ImageSwitch::ImageSwitch(Widget* widget, const Image& imageNormal, const Image& imageDown, int id) noexcept + : Widget(widget->getParentWindow()), + fImageNormal(imageNormal), + fImageDown(imageDown), + fIsDown(false), + fId(id), + fCallback(nullptr) +{ + DISTRHO_SAFE_ASSERT(fImageNormal.getSize() == fImageDown.getSize()); + + setSize(fImageNormal.getSize()); +} + +ImageSwitch::ImageSwitch(const ImageSwitch& imageSwitch) noexcept + : Widget(imageSwitch.getParentWindow()), + fImageNormal(imageSwitch.fImageNormal), + fImageDown(imageSwitch.fImageDown), + fIsDown(imageSwitch.fIsDown), + fId(imageSwitch.fId), + fCallback(imageSwitch.fCallback) +{ + DISTRHO_SAFE_ASSERT(fImageNormal.getSize() == fImageDown.getSize()); + + setSize(fImageNormal.getSize()); +} + +int ImageSwitch::getId() const noexcept +{ + return fId; +} + +void ImageSwitch::setId(int id) noexcept +{ + fId = id;; +} + +bool ImageSwitch::isDown() const noexcept +{ + return fIsDown; +} + +void ImageSwitch::setDown(bool down) noexcept +{ + if (fIsDown == down) + return; + + fIsDown = down; + repaint(); +} + +void ImageSwitch::setCallback(Callback* callback) noexcept +{ + fCallback = callback; +} + +void ImageSwitch::onDisplay() +{ + if (fIsDown) + fImageNormal.draw(); + else + fImageDown.draw(); +} + +bool ImageSwitch::onMouse(const MouseEvent& ev) +{ + if (ev.press && contains(ev.pos)) + { + fIsDown = !fIsDown; + + repaint(); + + if (fCallback != nullptr) + fCallback->imageSwitchClicked(this, fIsDown); + + return true; + } + + return false; +} + +// ----------------------------------------------------------------------- + +END_NAMESPACE_DGL diff --git a/libs/dgl/src/ImageToggle.cpp b/libs/dgl/src/ImageToggle.cpp deleted file mode 100644 index ac8e839..0000000 --- a/libs/dgl/src/ImageToggle.cpp +++ /dev/null @@ -1,147 +0,0 @@ -/* - * DISTRHO Plugin Framework (DPF) - * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com> - * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> - * - * Permission to use, copy, modify, and/or distribute this software for any purpose with - * or without fee is hereby granted, provided that the above copyright notice and this - * permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD - * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN - * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL - * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER - * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN - * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "../ImageToggle.hpp" - -#include <cassert> - -START_NAMESPACE_DGL - -// ----------------------------------------------------------------------- - -ImageToggle::ImageToggle(Window& parent, const Image& image) - : Widget(parent), - fImageNormal(image), - fImageHover(image), - fImageDown(image), - fCurImage(&fImageNormal), - fCurButton(-1), - fCallback(nullptr) -{ -} - -ImageToggle::ImageToggle(Widget* widget, const Image& image) - : Widget(widget->getParentWindow()), - fImageNormal(image), - fImageHover(image), - fImageDown(image), - fCurImage(&fImageNormal), - fCurButton(-1), - fCallback(nullptr) -{ -} - -ImageToggle::ImageToggle(Window& parent, const Image& imageNormal, const Image& imageHover, const Image& imageDown) - : Widget(parent), - fImageNormal(imageNormal), - fImageHover(imageHover), - fImageDown(imageDown), - fCurImage(&fImageNormal), - fCurButton(-1), - fCallback(nullptr) -{ - assert(fImageNormal.getSize() == fImageHover.getSize() && fImageHover.getSize() == fImageDown.getSize()); - - setSize(fCurImage->getSize()); -} - -ImageToggle::ImageToggle(Widget* widget, const Image& imageNormal, const Image& imageHover, const Image& imageDown) - : Widget(widget->getParentWindow()), - fImageNormal(imageNormal), - fImageHover(imageHover), - fImageDown(imageDown), - fCurImage(&fImageNormal), - fCurButton(-1), - fCallback(nullptr) -{ - assert(fImageNormal.getSize() == fImageHover.getSize() && fImageHover.getSize() == fImageDown.getSize()); - - setSize(fCurImage->getSize()); - setValue(0.f); -} - -ImageToggle::ImageToggle(const ImageToggle& imageToggle) - : Widget(imageToggle.getParentWindow()), - fImageNormal(imageToggle.fImageNormal), - fImageHover(imageToggle.fImageHover), - fImageDown(imageToggle.fImageDown), - fCurImage(&fImageNormal), - fCurButton(-1), - fCallback(imageToggle.fCallback) -{ - assert(fImageNormal.getSize() == fImageHover.getSize() && fImageHover.getSize() == fImageDown.getSize()); - - setSize(fCurImage->getSize()); -} - -void ImageToggle::setCallback(Callback* callback) -{ - fCallback = callback; -} - -float ImageToggle::getValue() -{ - return (fCurImage == &fImageNormal) ? 0.f : 1.f; -} - -void ImageToggle::setValue(float value) -{ - if (value == 1.f) - fCurImage = &fImageDown; - else if (value == 0.f) - fCurImage = &fImageNormal; - - repaint(); -} - -void ImageToggle::onDisplay() -{ - fCurImage->draw(getPos()); -} - -bool ImageToggle::onMouse(int button, bool press, int x, int y) -{ - if (press && getArea().contains(x, y)) - { - if (fCurImage != &fImageDown) - { - fCurImage = &fImageDown; - } - else if (fCurImage != &fImageNormal) - { - fCurImage = &fImageNormal; - } - - repaint(); - fCurButton = button; - if (fCallback != nullptr) - fCallback->imageToggleClicked(this, button); - - return true; - } - - return false; -} - -bool ImageToggle::onMotion(int, int) -{ - return false; -} - -// ----------------------------------------------------------------------- - -END_NAMESPACE_DGL diff --git a/libs/dgl/src/NanoVG.cpp b/libs/dgl/src/NanoVG.cpp new file mode 100644 index 0000000..b4e3103 --- /dev/null +++ b/libs/dgl/src/NanoVG.cpp @@ -0,0 +1,626 @@ +/* + * DISTRHO Plugin Framework (DPF) + * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com> + * + * Permission to use, copy, modify, and/or distribute this software for any purpose with + * or without fee is hereby granted, provided that the above copyright notice and this + * permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD + * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN + * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER + * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "../NanoVG.hpp" + +// ----------------------------------------------------------------------- + +#define NANOVG_GL2_IMPLEMENTATION +#include "nanovg/nanovg_gl.h" + +#if defined(NANOVG_GL2) +# define nvgCreateGL nvgCreateGL2 +# define nvgDeleteGL nvgDeleteGL2 +#elif defined(NANOVG_GL3) +# define nvgCreateGL nvgCreateGL3 +# define nvgDeleteGL nvgDeleteGL3 +#elif defined(NANOVG_GLES2) +# define nvgCreateGL nvgCreateGLES2 +# define nvgDeleteGL nvgDeleteGLES2 +#elif defined(NANOVG_GLES3) +# define nvgCreateGL nvgCreateGLES3 +# define nvgDeleteGL nvgDeleteGLES3 +#endif + +START_NAMESPACE_DGL + +// ----------------------------------------------------------------------- +// Conversions + +NanoVG::Color::Color() noexcept + : r(1.0f), g(1.0f), b(1.0f), a(1.0f) {} + +NanoVG::Color::Color(const NVGcolor& c) noexcept + : r(c.r), g(c.g), b(c.b), a(c.a) {} + +NanoVG::Color::operator NVGcolor() const noexcept +{ + NVGcolor nc = { r, g, b, a }; + return nc; +} + +NanoVG::Paint::Paint() noexcept + : radius(0.0f), feather(0.0f), innerColor(), outerColor(), imageId(0), repeat(REPEAT_NONE) +{ + std::memset(xform, 0, sizeof(float)*6); + std::memset(extent, 0, sizeof(float)*2); +} + +NanoVG::Paint::Paint(const NVGpaint& p) noexcept + : radius(p.radius), feather(p.feather), innerColor(p.innerColor), outerColor(p.outerColor), imageId(p.image), repeat(static_cast<PatternRepeat>(p.repeat)) +{ + std::memcpy(xform, p.xform, sizeof(float)*6); + std::memcpy(extent, p.extent, sizeof(float)*2); +} + +NanoVG::Paint::operator NVGpaint() const noexcept +{ + NVGpaint p; + p.radius = radius; + p.feather = feather; + p.innerColor = innerColor; + p.outerColor = outerColor; + p.image = imageId; + p.repeat = repeat; + std::memcpy(p.xform, xform, sizeof(float)*6); + std::memcpy(p.extent, extent, sizeof(float)*2); + return p; +} + +// ----------------------------------------------------------------------- +// NanoImage + +static NVGcontext* sLastContext = nullptr; + +NanoImage::NanoImage() noexcept + : fContext(nullptr), + fImageId(0) {} + +#if 0 +NanoImage::NanoImage(NanoImage& img) noexcept + : fContext(img.fContext), + fImageId(img.fImageId) +{ + img.fContext = nullptr; + img.fImageId = 0; +} +#endif + +NanoImage::NanoImage(const char* filename) + : fContext(sLastContext), + fImageId((fContext != nullptr) ? nvgCreateImage(fContext, filename) : 0) {} + +NanoImage::NanoImage(uchar* data, int ndata) + : fContext(sLastContext), + fImageId((fContext != nullptr) ? nvgCreateImageMem(fContext, data, ndata) : 0) {} + +NanoImage::NanoImage(int w, int h, const uchar* data) + : fContext(sLastContext), + fImageId((fContext != nullptr) ? nvgCreateImageRGBA(fContext, w, h, data) : 0) {} + +NanoImage::~NanoImage() +{ + if (fContext != nullptr && fImageId != 0) + nvgDeleteImage(fContext, fImageId); +} + +bool NanoImage::isValid() const noexcept +{ + return (fContext != nullptr && fImageId != 0); +} + +Size<int> NanoImage::getSize() const +{ + int w=0, h=0; + + if (fContext != nullptr && fImageId != 0) + nvgImageSize(fContext, fImageId, &w, &h); + + return Size<int>(w, h); +} + +void NanoImage::updateImage(const uchar* data) +{ + if (fContext != nullptr && fImageId != 0) + nvgUpdateImage(fContext, fImageId, data); +} + +NanoImage NanoImage::operator=(NanoImage img) noexcept +{ + if (fContext != nullptr && fImageId != 0) + nvgDeleteImage(fContext, fImageId); + + fContext = img.fContext; + fImageId = img.fImageId; + + img.fContext = nullptr; + img.fImageId = 0; + + return *this; +} + +// ----------------------------------------------------------------------- +// NanoVG + +NanoVG::NanoVG() + : fContext(nvgCreateGL(512, 512, NVG_ANTIALIAS)) +{ + DISTRHO_SAFE_ASSERT_RETURN(fContext != nullptr,); +} + +NanoVG::NanoVG(int textAtlasWidth, int textAtlasHeight) + : fContext(nvgCreateGL(textAtlasWidth, textAtlasHeight, NVG_ANTIALIAS)) +{ + DISTRHO_SAFE_ASSERT_RETURN(fContext != nullptr,); +} + +NanoVG::~NanoVG() +{ + if (fContext == nullptr) + return; + + nvgDeleteGL(fContext); +} + +// ----------------------------------------------------------------------- + +void NanoVG::beginFrame(int width, int height, float scaleFactor, Alpha alpha) +{ + nvgBeginFrame(fContext, width, height, scaleFactor, static_cast<NVGalpha>(alpha)); +} + +void NanoVG::endFrame() +{ + nvgEndFrame(fContext); +} + +// ----------------------------------------------------------------------- +// Color utils + +NanoVG::Color NanoVG::RGB(uchar r, uchar g, uchar b) +{ + return nvgRGB(r, g, b); +} + +NanoVG::Color NanoVG::RGBf(float r, float g, float b) +{ + return nvgRGBf(r, g, b); +} + +NanoVG::Color NanoVG::RGBA(uchar r, uchar g, uchar b, uchar a) +{ + return nvgRGBA(r, g, b, a); +} + +NanoVG::Color NanoVG::RGBAf(float r, float g, float b, float a) +{ + return nvgRGBAf(r, g, b, a); +} + +NanoVG::Color NanoVG::lerpRGBA(const Color& c0, const Color& c1, float u) +{ + return nvgLerpRGBA(c0, c1, u); +} + +NanoVG::Color NanoVG::HSL(float h, float s, float l) +{ + return nvgHSL(h, s, l); +} + +NanoVG::Color NanoVG::HSLA(float h, float s, float l, uchar a) +{ + return nvgHSLA(h, s, l, a); +} + +// ----------------------------------------------------------------------- +// State Handling + +void NanoVG::save() +{ + nvgSave(fContext); +} + +void NanoVG::restore() +{ + nvgRestore(fContext); +} + +void NanoVG::reset() +{ + nvgReset(fContext); +} + +// ----------------------------------------------------------------------- +// Render styles + +void NanoVG::strokeColor(const Color& color) +{ + nvgStrokeColor(fContext, color); +} + +void NanoVG::strokePaint(const Paint& paint) +{ + nvgStrokePaint(fContext, paint); +} + +void NanoVG::fillColor(const Color& color) +{ + nvgFillColor(fContext, color); +} + +void NanoVG::fillPaint(const Paint& paint) +{ + nvgFillPaint(fContext, paint); +} + +void NanoVG::miterLimit(float limit) +{ + nvgMiterLimit(fContext, limit); +} + +void NanoVG::strokeWidth(float size) +{ + nvgStrokeWidth(fContext, size); +} + +void NanoVG::lineCap(NanoVG::LineCap cap) +{ + nvgLineCap(fContext, cap); +} + +void NanoVG::lineJoin(NanoVG::LineCap join) +{ + nvgLineJoin(fContext, join); +} + +// ----------------------------------------------------------------------- +// Transforms + +void NanoVG::resetTransform() +{ + nvgResetTransform(fContext); +} + +void NanoVG::transform(float a, float b, float c, float d, float e, float f) +{ + nvgTransform(fContext, a, b, c, d, e, f); +} + +void NanoVG::translate(float x, float y) +{ + nvgTranslate(fContext, x, y); +} + +void NanoVG::rotate(float angle) +{ + nvgRotate(fContext, angle); +} + +void NanoVG::skewX(float angle) +{ + nvgSkewX(fContext, angle); +} + +void NanoVG::skewY(float angle) +{ + nvgSkewY(fContext, angle); +} + +void NanoVG::scale(float x, float y) +{ + nvgScale(fContext, x, y); +} + +void NanoVG::currentTransform(float xform[6]) +{ + nvgCurrentTransform(fContext, xform); +} + +void NanoVG::transformIdentity(float dst[6]) +{ + nvgTransformIdentity(dst); +} + +void NanoVG::transformTranslate(float dst[6], float tx, float ty) +{ + nvgTransformTranslate(dst, tx, ty); +} + +void NanoVG::transformScale(float dst[6], float sx, float sy) +{ + nvgTransformScale(dst, sx, sy); +} + +void NanoVG::transformRotate(float dst[6], float a) +{ + nvgTransformRotate(dst, a); +} + +void NanoVG::transformSkewX(float dst[6], float a) +{ + nvgTransformSkewX(dst, a); +} + +void NanoVG::transformSkewY(float dst[6], float a) +{ + nvgTransformSkewY(dst, a); +} + +void NanoVG::transformMultiply(float dst[6], const float src[6]) +{ + nvgTransformMultiply(dst, src); +} + +void NanoVG::transformPremultiply(float dst[6], const float src[6]) +{ + nvgTransformPremultiply(dst, src); +} + +int NanoVG::transformInverse(float dst[6], const float src[6]) +{ + return nvgTransformInverse(dst, src); +} + +void NanoVG::transformPoint(float& dstx, float& dsty, const float xform[6], float srcx, float srcy) +{ + nvgTransformPoint(&dstx, &dsty, xform, srcx, srcy); +} + +float NanoVG::degToRad(float deg) +{ + return nvgDegToRad(deg); +} + +float NanoVG::radToDeg(float rad) +{ + return nvgRadToDeg(rad); +} + +// ----------------------------------------------------------------------- +// Images + +NanoImage NanoVG::createImage(const char* filename) +{ + sLastContext = fContext; + return NanoImage(filename); +} + +NanoImage NanoVG::createImageMem(uchar* data, int ndata) +{ + sLastContext = fContext; + return NanoImage(data, ndata); +} + +NanoImage NanoVG::createImageRGBA(int w, int h, const uchar* data) +{ + sLastContext = fContext; + return NanoImage(w, h, data); +} + +// ----------------------------------------------------------------------- +// Paints + +NanoVG::Paint NanoVG::linearGradient(float sx, float sy, float ex, float ey, const NanoVG::Color& icol, const NanoVG::Color& ocol) +{ + return nvgLinearGradient(fContext, sx, sy, ex, ey, icol, ocol); +} + +NanoVG::Paint NanoVG::boxGradient(float x, float y, float w, float h, float r, float f, const NanoVG::Color& icol, const NanoVG::Color& ocol) +{ + return nvgBoxGradient(fContext, x, y, w, h, r, f, icol, ocol); +} + +NanoVG::Paint NanoVG::radialGradient(float cx, float cy, float inr, float outr, const NanoVG::Color& icol, const NanoVG::Color& ocol) +{ + return nvgRadialGradient(fContext, cx, cy, inr, outr, icol, ocol); +} + +NanoVG::Paint NanoVG::imagePattern(float ox, float oy, float ex, float ey, float angle, const NanoImage& image, NanoVG::PatternRepeat repeat) +{ + return nvgImagePattern(fContext, ox, oy, ex, ey, angle, image.fImageId, repeat); +} + +// ----------------------------------------------------------------------- +// Scissoring + +void NanoVG::scissor(float x, float y, float w, float h) +{ + nvgScissor(fContext, x, y, w, h); +} + +void NanoVG::resetScissor() +{ + nvgResetScissor(fContext); +} + +// ----------------------------------------------------------------------- +// Paths + +void NanoVG::beginPath() +{ + nvgBeginPath(fContext); +} + +void NanoVG::moveTo(float x, float y) +{ + nvgMoveTo(fContext, x, y); +} + +void NanoVG::lineTo(float x, float y) +{ + nvgLineTo(fContext, x, y); +} + +void NanoVG::bezierTo(float c1x, float c1y, float c2x, float c2y, float x, float y) +{ + nvgBezierTo(fContext, c1x, c1y, c2x, c2y, x, y); +} + +void NanoVG::arcTo(float x1, float y1, float x2, float y2, float radius) +{ + nvgArcTo(fContext, x1, y1, x2, y2, radius); +} + +void NanoVG::closePath() +{ + nvgClosePath(fContext); +} + +void NanoVG::pathWinding(NanoVG::Winding dir) +{ + nvgPathWinding(fContext, dir); +} + +void NanoVG::arc(float cx, float cy, float r, float a0, float a1, NanoVG::Winding dir) +{ + nvgArc(fContext, cx, cy, r, a0, a1, dir); +} + +void NanoVG::rect(float x, float y, float w, float h) +{ + nvgRect(fContext, x, y, w, h); +} + +void NanoVG::roundedRect(float x, float y, float w, float h, float r) +{ + nvgRoundedRect(fContext, x, y, w, h, r); +} + +void NanoVG::ellipse(float cx, float cy, float rx, float ry) +{ + nvgEllipse(fContext, cx, cy, rx, ry); +} + +void NanoVG::circle(float cx, float cy, float r) +{ + nvgCircle(fContext, cx, cy, r); +} + +void NanoVG::fill() +{ + nvgFill(fContext); +} + +void NanoVG::stroke() +{ + nvgStroke(fContext); +} + +// ----------------------------------------------------------------------- +// Text + +NanoVG::FontId NanoVG::createFont(const char* name, const char* filename) +{ + return nvgCreateFont(fContext, name, filename); +} + +NanoVG::FontId NanoVG::createFontMem(const char* name, uchar* data, int ndata, bool freeData) +{ + return nvgCreateFontMem(fContext, name, data, ndata, freeData); +} + +NanoVG::FontId NanoVG::findFont(const char* name) +{ + return nvgFindFont(fContext, name); +} + +void NanoVG::fontSize(float size) +{ + nvgFontSize(fContext, size); +} + +void NanoVG::fontBlur(float blur) +{ + nvgFontBlur(fContext, blur); +} + +void NanoVG::textLetterSpacing(float spacing) +{ + nvgTextLetterSpacing(fContext, spacing); +} + +void NanoVG::textLineHeight(float lineHeight) +{ + nvgTextLineHeight(fContext, lineHeight); +} + +void NanoVG::textAlign(NanoVG::Align align) +{ + nvgTextAlign(fContext, align); +} + +void NanoVG::textAlign(int align) +{ + nvgTextAlign(fContext, align); +} + +void NanoVG::fontFaceId(FontId font) +{ + nvgFontFaceId(fContext, font); +} + +void NanoVG::fontFace(const char* font) +{ + nvgFontFace(fContext, font); +} + +float NanoVG::text(float x, float y, const char* string, const char* end) +{ + return nvgText(fContext, x, y, string, end); +} + +void NanoVG::textBox(float x, float y, float breakRowWidth, const char* string, const char* end) +{ + nvgTextBox(fContext, x, y, breakRowWidth, string, end); +} + +float NanoVG::textBounds(float x, float y, const char* string, const char* end, Rectangle<float>& bounds) +{ + float b[4]; + const float ret = nvgTextBounds(fContext, x, y, string, end, b); + bounds = Rectangle<float>(b[0], b[1], b[2], b[3]); + return ret; +} + +void NanoVG::textBoxBounds(float x, float y, float breakRowWidth, const char* string, const char* end, float* bounds) +{ + nvgTextBoxBounds(fContext, x, y, breakRowWidth, string, end, bounds); +} + +int NanoVG::textGlyphPositions(float x, float y, const char* string, const char* end, NanoVG::GlyphPosition* positions, int maxPositions) +{ + return nvgTextGlyphPositions(fContext, x, y, string, end, (NVGglyphPosition*)positions, maxPositions); +} + +void NanoVG::textMetrics(float* ascender, float* descender, float* lineh) +{ + nvgTextMetrics(fContext, ascender, descender, lineh); +} + +int NanoVG::textBreakLines(const char* string, const char* end, float breakRowWidth, NanoVG::TextRow* rows, int maxRows) +{ + return nvgTextBreakLines(fContext, string, end, breakRowWidth, (NVGtextRow*)rows, maxRows); +} + +// ----------------------------------------------------------------------- + +END_NAMESPACE_DGL + +extern "C" { +#include "nanovg/nanovg.c" +} + +// ----------------------------------------------------------------------- diff --git a/libs/dgl/src/Widget.cpp b/libs/dgl/src/Widget.cpp index 0aa46f7..aee727b 100644 --- a/libs/dgl/src/Widget.cpp +++ b/libs/dgl/src/Widget.cpp @@ -14,12 +14,9 @@ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#include "../App.hpp" #include "../Widget.hpp" #include "../Window.hpp" -#include <cassert> - START_NAMESPACE_DGL // ----------------------------------------------------------------------- @@ -27,6 +24,7 @@ START_NAMESPACE_DGL Widget::Widget(Window& parent) : fParent(parent), + fNeedsFullViewport(false), fVisible(true) { fParent._addWidget(this); @@ -61,176 +59,175 @@ void Widget::hide() setVisible(false); } -int Widget::getX() const noexcept +int Widget::getWidth() const noexcept { - return fArea.getX(); + return fArea.getWidth(); } -int Widget::getY() const noexcept +int Widget::getHeight() const noexcept { - return fArea.getY(); + return fArea.getHeight(); } -const Point<int>& Widget::getPos() const noexcept +const Size<int>& Widget::getSize() const noexcept { - return fArea.getPos(); + return fArea.getSize(); } -void Widget::setX(int x) +void Widget::setWidth(int width) noexcept { - if (fArea.getX() == x) + if (fArea.getWidth() == width) return; - fArea.setX(x); + ResizeEvent ev; + ev.oldSize = fArea.getSize(); + ev.size = Size<int>(width, fArea.getHeight()); + + fArea.setWidth(width); + onResize(ev); + fParent.repaint(); } -void Widget::setY(int y) +void Widget::setHeight(int height) noexcept { - if (fArea.getY() == y) + if (fArea.getHeight() == height) return; - fArea.setY(y); + ResizeEvent ev; + ev.oldSize = fArea.getSize(); + ev.size = Size<int>(fArea.getWidth(), height); + + fArea.setHeight(height); + onResize(ev); + fParent.repaint(); } -void Widget::setPos(int x, int y) +void Widget::setSize(int width, int height) noexcept { - setPos(Point<int>(x, y)); + setSize(Size<int>(width, height)); } -void Widget::setPos(const Point<int>& pos) +void Widget::setSize(const Size<int>& size) noexcept { - if (fArea.getPos() == pos) + if (fArea.getSize() == size) return; - fArea.setPos(pos); - fParent.repaint(); -} + ResizeEvent ev; + ev.oldSize = fArea.getSize(); + ev.size = size; -void Widget::move(int x, int y) -{ - fArea.move(x, y); - fParent.repaint(); -} + fArea.setSize(size); + onResize(ev); -void Widget::move(const Point<int>& pos) -{ - fArea.move(pos); fParent.repaint(); } -int Widget::getWidth() const noexcept +int Widget::getAbsoluteX() const noexcept { - return fArea.getWidth(); + return fArea.getX(); } -int Widget::getHeight() const noexcept +int Widget::getAbsoluteY() const noexcept { - return fArea.getHeight(); + return fArea.getY(); } -const Size<int>& Widget::getSize() const noexcept +const Point<int>& Widget::getAbsolutePos() const noexcept { - return fArea.getSize(); + return fArea.getPos(); } -void Widget::setWidth(int width) +void Widget::setAbsoluteX(int x) noexcept { - if (fArea.getWidth() == width) + if (fArea.getX() == x) return; - fArea.setWidth(width); + fArea.setX(x); fParent.repaint(); } -void Widget::setHeight(int height) +void Widget::setAbsoluteY(int y) noexcept { - if (fArea.getHeight() == height) + if (fArea.getY() == y) return; - fArea.setHeight(height); + fArea.setY(y); fParent.repaint(); } -void Widget::setSize(const Size<int>& size) +void Widget::setAbsolutePos(int x, int y) noexcept { - if (fArea.getSize() == size) - return; - - fArea.setSize(size); - fParent.repaint(); + setAbsolutePos(Point<int>(x, y)); } -const Rectangle<int>& Widget::getArea() const noexcept +void Widget::setAbsolutePos(const Point<int>& pos) noexcept { - return fArea; + if (fArea.getPos() == pos) + return; + + fArea.setPos(pos); + fParent.repaint(); } -uint32_t Widget::getEventTimestamp() +App& Widget::getParentApp() const noexcept { - return fParent.getEventTimestamp(); + return fParent.getApp(); } -int Widget::getModifiers() +Window& Widget::getParentWindow() const noexcept { - return fParent.getModifiers(); + return fParent; } -App& Widget::getParentApp() const noexcept +bool Widget::contains(int x, int y) const noexcept { - return fParent.getApp(); + return (x >= 0 && y >= 0 && x < fArea.getWidth() && y < fArea.getHeight()); } -Window& Widget::getParentWindow() const noexcept +bool Widget::contains(const Point<int>& pos) const noexcept { - return fParent; + return contains(pos.getX(), pos.getY()); } -void Widget::repaint() +void Widget::repaint() noexcept { fParent.repaint(); } -bool Widget::onKeyboard(bool, uint32_t) +bool Widget::onKeyboard(const KeyboardEvent&) { return false; } -bool Widget::onMouse(int, bool, int, int) +bool Widget::onSpecial(const SpecialEvent&) { return false; } -bool Widget::onMotion(int, int) +bool Widget::onMouse(const MouseEvent&) { return false; } -bool Widget::onScroll(int, int, float, float) +bool Widget::onMotion(const MotionEvent&) { return false; } -bool Widget::onSpecial(bool, Key) +bool Widget::onScroll(const ScrollEvent&) { return false; } -void Widget::onReshape(int width, int height) +void Widget::onResize(const ResizeEvent&) { - glEnable(GL_BLEND); - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - glOrtho(0, width, height, 0, 0.0f, 1.0f); - glViewport(0, 0, width, height); - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); } -void Widget::onClose() +void Widget::setNeedsFullViewport(bool yesNo) noexcept { + fNeedsFullViewport = yesNo; } // ----------------------------------------------------------------------- diff --git a/libs/dgl/src/Window.cpp b/libs/dgl/src/Window.cpp index 20cbf9d..0ee57f4 100644 --- a/libs/dgl/src/Window.cpp +++ b/libs/dgl/src/Window.cpp @@ -15,27 +15,20 @@ */ // we need this for now -#define XKEYFOCUSGRAB 1 +#define PUGL_GRAB_FOCUS 1 -#include "../App.hpp" +#include "AppPrivateData.hpp" #include "../Widget.hpp" #include "../Window.hpp" -#include <cassert> -#include <cstdio> -#include <list> - #include "pugl/pugl.h" #if defined(DISTRHO_OS_WINDOWS) # include "pugl/pugl_win.cpp" #elif defined(DISTRHO_OS_MAC) -# include "pugl/pugl_osx_extended.h" extern "C" { -struct PuglViewImpl { - int width; - int height; -};} +# include "pugl/pugl_osx.m" +} #elif defined(DISTRHO_OS_LINUX) # include <sys/types.h> # include <unistd.h> @@ -69,13 +62,11 @@ Window* dgl_lastUiParent = nullptr; // ----------------------------------------------------------------------- // Window Private -class Window::PrivateData -{ -public: +struct Window::PrivateData { PrivateData(App& app, Window* const self) : fApp(app), fSelf(self), - fView(puglCreate(0, "Window", 100, 100, true, false)), + fView(puglInit(nullptr, nullptr)), fFirstInit(true), fVisible(false), fResizable(true), @@ -86,7 +77,8 @@ public: xDisplay(nullptr), xWindow(0) #elif defined(DISTRHO_OS_MAC) - fNeedsIdle(true) + fNeedsIdle(true), + xWindow(nullptr) #else _dummy('\0') #endif @@ -98,7 +90,7 @@ public: PrivateData(App& app, Window* const self, Window& parent) : fApp(app), fSelf(self), - fView(puglCreate(0, "Window", 100, 100, true, false)), + fView(puglInit(nullptr, nullptr)), fFirstInit(true), fVisible(false), fResizable(true), @@ -110,7 +102,8 @@ public: xDisplay(nullptr), xWindow(0) #elif defined(DISTRHO_OS_MAC) - fNeedsIdle(false) + fNeedsIdle(false), + xWindow(nullptr) #else _dummy('\0') #endif @@ -128,7 +121,7 @@ public: PrivateData(App& app, Window* const self, const intptr_t parentId) : fApp(app), fSelf(self), - fView(puglCreate(parentId, "Window", 100, 100, (parentId == 0), (parentId != 0))), + fView(puglInit(nullptr, nullptr)), fFirstInit(true), fVisible(parentId != 0), fResizable(parentId == 0), @@ -139,14 +132,19 @@ public: xDisplay(nullptr), xWindow(0) #elif defined(DISTRHO_OS_MAC) - fNeedsIdle(false) + fNeedsIdle(false), + xWindow(nullptr) #else _dummy('\0') #endif { - if (parentId != 0) { + if (parentId != 0) + { DBG("Creating embedded window..."); DBGF; - } else { + puglInitWindowParent(fView, parentId); + } + else + { DBG("Creating window without parent..."); DBGF; } @@ -155,7 +153,8 @@ public: if (parentId != 0) { DBG("NOTE: Embed window is always visible and non-resizable\n"); - fApp._oneShown(); + puglShowWindow(fView); + fApp.pData->oneShown(); fFirstInit = false; } } @@ -171,6 +170,8 @@ public: dgl_lastUiParent = fSelf; + puglInitResizable(fView, fResizable); + puglSetHandle(fView, this); puglSetDisplayFunc(fView, onDisplayCallback); puglSetKeyboardFunc(fView, onKeyboardCallback); @@ -181,32 +182,31 @@ public: puglSetReshapeFunc(fView, onReshapeCallback); puglSetCloseFunc(fView, onCloseCallback); -#if defined(DISTRHO_OS_WINDOWS) + puglCreateWindow(fView, nullptr); + PuglInternals* impl = fView->impl; +#if defined(DISTRHO_OS_WINDOWS) hwnd = impl->hwnd; - assert(hwnd != 0); + DISTRHO_SAFE_ASSERT(hwnd != 0); +#elif defined(DISTRHO_OS_MAC) + xWindow = impl->window; + DISTRHO_SAFE_ASSERT(xWindow != nullptr); #elif defined(DISTRHO_OS_LINUX) - PuglInternals* impl = fView->impl; xDisplay = impl->display; xWindow = impl->win; - assert(xWindow != 0); + DISTRHO_SAFE_ASSERT(xWindow != 0); if (! fUsingEmbed) { pid_t pid = getpid(); Atom _nwp = XInternAtom(xDisplay, "_NET_WM_PID", True); - XChangeProperty(xDisplay, xWindow, _nwp, XA_CARDINAL, 32, PropModeReplace, (const unsigned char*)&pid, 1); + XChangeProperty(xDisplay, xWindow, _nwp, XA_CARDINAL, 32, PropModeReplace, (const uchar*)&pid, 1); } #endif - DBG("Success!\n"); - -#if 0 - // process any initial events - puglProcessEvents(fView); -#endif + fApp.pData->windows.push_back(fSelf); - fApp._addWindow(fSelf); + DBG("Success!\n"); } ~PrivateData() @@ -218,7 +218,7 @@ public: if (fSelf != nullptr) { - fApp._removeWindow(fSelf); + fApp.pData->windows.remove(fSelf); fSelf = nullptr; } @@ -229,10 +229,12 @@ public: } #if defined(DISTRHO_OS_WINDOWS) - hwnd = 0; + hwnd = 0; +#elif defined(DISTRHO_OS_MAC) + xWindow = nullptr; #elif defined(DISTRHO_OS_LINUX) - xDisplay = nullptr; - xWindow = 0; + xDisplay = nullptr; + xWindow = 0; #endif DBG("Success!\n"); @@ -247,7 +249,7 @@ public: if (! fFirstInit) { - fApp._oneHidden(); + fApp.pData->oneHidden(); fFirstInit = true; } } @@ -275,6 +277,49 @@ public: // ------------------------------------------------------------------- + void exec_init() + { + DBG("Window modal loop starting..."); DBGF; + DISTRHO_SAFE_ASSERT_RETURN(fModal.parent != nullptr, setVisible(true)); + + fModal.enabled = true; + fModal.parent->fModal.childFocus = this; + +#ifdef DISTRHO_OS_WINDOWS + // Center this window + PuglInternals* const parentImpl = fModal.parent->fView->impl; + + RECT curRect; + RECT parentRect; + GetWindowRect(hwnd, &curRect); + GetWindowRect(parentImpl->hwnd, &parentRect); + + int x = parentRect.left+(parentRect.right-curRect.right)/2; + int y = parentRect.top +(parentRect.bottom-curRect.bottom)/2; + + SetWindowPos(hwnd, 0, x, y, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER); + UpdateWindow(hwnd); +#endif + + fModal.parent->setVisible(true); + setVisible(true); + + DBG("Ok\n"); + } + + void exec_fini() + { + DBG("Window modal loop stopping..."); DBGF; + fModal.enabled = false; + + if (fModal.parent != nullptr) + fModal.parent->fModal.childFocus = nullptr; + + DBG("Ok\n"); + } + + // ------------------------------------------------------------------- + void focus() { DBG("Window focus\n"); @@ -283,7 +328,9 @@ public: SetActiveWindow(hwnd); SetFocus(hwnd); #elif defined(DISTRHO_OS_MAC) - puglImplFocus(fView); + // TODO + //[NSApp activateIgnoringOtherApps:YES]; + //[xWindow makeKeyAndOrderFront:xWindow]; #elif defined(DISTRHO_OS_LINUX) XRaiseWindow(xDisplay, xWindow); XSetInputFocus(xDisplay, xWindow, RevertToPointerRoot, CurrentTime); @@ -291,19 +338,8 @@ public: #endif } - void repaint() - { - //DBG("Window repaint\n"); - puglPostRedisplay(fView); - } - // ------------------------------------------------------------------- - bool isVisible() const noexcept - { - return fVisible; - } - void setVisible(const bool yesNo) { if (fVisible == yesNo) @@ -322,7 +358,7 @@ public: fVisible = yesNo; if (yesNo && fFirstInit) - setSize(static_cast<unsigned int>(fView->width), static_cast<unsigned int>(fView->height), true); + setSize(static_cast<uint>(fView->width), static_cast<uint>(fView->height), true); #if defined(DISTRHO_OS_WINDOWS) if (yesNo) @@ -332,7 +368,10 @@ public: UpdateWindow(hwnd); #elif defined(DISTRHO_OS_MAC) - puglImplSetVisible(fView, yesNo); + if (yesNo) + [xWindow setIsVisible:YES]; + else + [xWindow setIsVisible:NO]; #elif defined(DISTRHO_OS_LINUX) if (yesNo) XMapRaised(xDisplay, xWindow); @@ -346,7 +385,7 @@ public: { if (fFirstInit) { - fApp._oneShown(); + fApp.pData->oneShown(); fFirstInit = false; } } @@ -356,11 +395,6 @@ public: // ------------------------------------------------------------------- - bool isResizable() const noexcept - { - return fResizable; - } - void setResizable(const bool yesNo) { if (fResizable == yesNo) @@ -378,27 +412,12 @@ public: fResizable = yesNo; - setSize(static_cast<unsigned int>(fView->width), static_cast<unsigned int>(fView->height), true); + setSize(static_cast<uint>(fView->width), static_cast<uint>(fView->height), true); } // ------------------------------------------------------------------- - int getWidth() const noexcept - { - return fView->width; - } - - int getHeight() const noexcept - { - return fView->height; - } - - Size<int> getSize() const noexcept - { - return Size<int>(fView->width, fView->height); - } - - void setSize(unsigned int width, unsigned int height, const bool forced = false) + void setSize(uint width, uint height, const bool forced = false) { if (width == 0 || height == 0) { @@ -431,7 +450,18 @@ public: if (! forced) UpdateWindow(hwnd); #elif defined(DISTRHO_OS_MAC) - puglImplSetSize(fView, width, height, forced); + [xWindow setContentSize:NSMakeSize(width, height)]; +# if 0 + NSRect frame = [xWindow frame]; + frame.origin.y -= height - frame.size.height; + frame.size.width = width; + frame.size.height = height+20; + + //if (forced) + // [xWindow setFrame:frame]; + //else + [xWindow setFrame:frame display:YES animate:NO]; +# endif #elif defined(DISTRHO_OS_LINUX) XResizeWindow(xDisplay, xWindow, width, height); @@ -455,7 +485,7 @@ public: XFlush(xDisplay); #endif - repaint(); + puglPostRedisplay(fView); } // ------------------------------------------------------------------- @@ -467,7 +497,12 @@ public: #if defined(DISTRHO_OS_WINDOWS) SetWindowTextA(hwnd, title); #elif defined(DISTRHO_OS_MAC) - puglImplSetTitle(fView, title); + NSString* titleString = [[NSString alloc] + initWithBytes:title + length:strlen(title) + encoding:NSUTF8StringEncoding]; + + [xWindow setTitle:titleString]; #elif defined(DISTRHO_OS_LINUX) XStoreName(xDisplay, xWindow, title); #endif @@ -486,28 +521,6 @@ public: // ------------------------------------------------------------------- - App& getApp() const noexcept - { - return fApp; - } - - int getModifiers() const - { - return puglGetModifiers(fView); - } - - uint32_t getEventTimestamp() const - { - return puglGetEventTimestamp(fView); - } - - intptr_t getWindowId() const - { - return puglGetNativeWindow(fView); - } - - // ------------------------------------------------------------------- - void addWidget(Widget* const widget) { fWidgets.push_back(widget); @@ -524,157 +537,185 @@ public: #ifdef DISTRHO_OS_MAC if (fNeedsIdle) - puglImplIdle(fView); -#endif - - if (fModal.enabled && fModal.parent != nullptr) - fModal.parent->idle(); - } - - // ------------------------------------------------------------------- - - void exec_init() - { - DBG("Window modal loop starting..."); DBGF; - assert(fModal.parent != nullptr); - - if (fModal.parent == nullptr) { - DBG("Failed, there's no modal parent!\n"); - return setVisible(true); - } + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + NSEvent* event; - fModal.enabled = true; - fModal.parent->fModal.childFocus = this; - -#ifdef DISTRHO_OS_WINDOWS - // Center this window - PuglInternals* const parentImpl = fModal.parent->fView->impl; + for (;;) + { + event = [NSApp + nextEventMatchingMask:NSAnyEventMask + untilDate:[NSDate distantPast] + inMode:NSDefaultRunLoopMode + dequeue:YES]; - RECT curRect; - RECT parentRect; - GetWindowRect(hwnd, &curRect); - GetWindowRect(parentImpl->hwnd, &parentRect); + if (event == nil) + break; - int x = parentRect.left+(parentRect.right-curRect.right)/2; - int y = parentRect.top +(parentRect.bottom-curRect.bottom)/2; + [NSApp sendEvent: event]; + } - SetWindowPos(hwnd, 0, x, y, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER); - UpdateWindow(hwnd); + [pool release]; + } #endif - fModal.parent->setVisible(true); - setVisible(true); - - DBG("Ok\n"); - } - - void exec_fini() - { - DBG("Window modal loop stopping..."); DBGF; - fModal.enabled = false; - - if (fModal.parent != nullptr) - fModal.parent->fModal.childFocus = nullptr; - - DBG("Ok\n"); + if (fModal.enabled && fModal.parent != nullptr) + fModal.parent->idle(); } // ------------------------------------------------------------------- -protected: void onDisplay() { - //DBG("PUGL: onDisplay\n"); - - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - glLoadIdentity(); + fSelf->onDisplayBefore(); FOR_EACH_WIDGET(it) { Widget* const widget(*it); if (widget->isVisible()) - widget->onDisplay(); + { + // reset color + glColor4f(1.0f, 1.0f, 1.0f, 1.0f); + + if (widget->fNeedsFullViewport || widget->fArea == Rectangle<int>(0, 0, fView->width, fView->height)) + { + // full viewport size + glViewport(0, 0, fView->width, fView->height); + + // display widget + widget->onDisplay(); + } + else + { + // limit viewport to widget bounds + glViewport(widget->getAbsoluteX(), fView->height - widget->getHeight() - widget->getAbsoluteY(), widget->getWidth(), widget->getHeight()); + + // scale contents to match viewport size + glPushMatrix(); + glScalef(float(fView->width)/float(widget->getWidth()), float(fView->height)/float(widget->getHeight()), 1.0f); + + // display widget + widget->onDisplay(); + + // done + glPopMatrix(); + } + } } + + fSelf->onDisplayAfter(); } - void onKeyboard(const bool press, const uint32_t key) + void onKeyboard(const bool press, const uint key) { DBGp("PUGL: onKeyboard : %i %i\n", press, key); if (fModal.childFocus != nullptr) return fModal.childFocus->focus(); + Widget::KeyboardEvent ev; + ev.press = press; + ev.key = key; + ev.mod = static_cast<Modifier>(puglGetModifiers(fView)); + ev.time = puglGetEventTimestamp(fView); + FOR_EACH_WIDGET_INV(rit) { Widget* const widget(*rit); - if (widget->isVisible() && widget->onKeyboard(press, key)) + if (widget->isVisible() && widget->onKeyboard(ev)) break; } } - void onMouse(const int button, const bool press, const int x, const int y) + void onSpecial(const bool press, const Key key) { - DBGp("PUGL: onMouse : %i %i %i %i\n", button, press, x, y); + DBGp("PUGL: onSpecial : %i %i\n", press, key); if (fModal.childFocus != nullptr) return fModal.childFocus->focus(); + Widget::SpecialEvent ev; + ev.press = press; + ev.key = key; + ev.mod = static_cast<Modifier>(puglGetModifiers(fView)); + ev.time = puglGetEventTimestamp(fView); + FOR_EACH_WIDGET_INV(rit) { Widget* const widget(*rit); - if (widget->isVisible() && widget->onMouse(button, press, x, y)) + if (widget->isVisible() && widget->onSpecial(ev)) break; } } - void onMotion(const int x, const int y) + void onMouse(const int button, const bool press, const int x, const int y) { - DBGp("PUGL: onMotion : %i %i\n", x, y); + DBGp("PUGL: onMouse : %i %i %i %i\n", button, press, x, y); if (fModal.childFocus != nullptr) - return; + return fModal.childFocus->focus(); + + Widget::MouseEvent ev; + ev.button = button; + ev.press = press; + ev.mod = static_cast<Modifier>(puglGetModifiers(fView)); + ev.time = puglGetEventTimestamp(fView); FOR_EACH_WIDGET_INV(rit) { Widget* const widget(*rit); - if (widget->isVisible() && widget->onMotion(x, y)) + ev.pos = Point<int>(x-widget->getAbsoluteX(), y-widget->getAbsoluteY()); + + if (widget->isVisible() && widget->onMouse(ev)) break; } } - void onScroll(const int x, const int y, const float dx, const float dy) + void onMotion(const int x, const int y) { - DBGp("PUGL: onScroll : %i %i %f %f\n", x, y, dx, dy); + DBGp("PUGL: onMotion : %i %i\n", x, y); if (fModal.childFocus != nullptr) return; + Widget::MotionEvent ev; + ev.mod = static_cast<Modifier>(puglGetModifiers(fView)); + ev.time = puglGetEventTimestamp(fView); + FOR_EACH_WIDGET_INV(rit) { Widget* const widget(*rit); - if (widget->isVisible() && widget->onScroll(x, y, dx, dy)) + ev.pos = Point<int>(x-widget->getAbsoluteX(), y-widget->getAbsoluteY()); + + if (widget->isVisible() && widget->onMotion(ev)) break; } } - void onSpecial(const bool press, const Key key) + void onScroll(const int x, const int y, const float dx, const float dy) { - DBGp("PUGL: onSpecial : %i %i\n", press, key); + DBGp("PUGL: onScroll : %i %i %f %f\n", x, y, dx, dy); if (fModal.childFocus != nullptr) return; + Widget::ScrollEvent ev; + ev.delta = Point<float>(dx, dy); + ev.mod = static_cast<Modifier>(puglGetModifiers(fView)); + ev.time = puglGetEventTimestamp(fView); + FOR_EACH_WIDGET_INV(rit) { Widget* const widget(*rit); - if (widget->isVisible() && widget->onSpecial(press, key)) + ev.pos = Point<int>(x-widget->getAbsoluteX(), y-widget->getAbsoluteY()); + + if (widget->isVisible() && widget->onScroll(ev)) break; } } @@ -683,10 +724,14 @@ protected: { DBGp("PUGL: onReshape : %i %i\n", width, height); + fSelf->onReshape(width, height); + FOR_EACH_WIDGET(it) { Widget* const widget(*it); - widget->onReshape(width, height); + + if (widget->fNeedsFullViewport) + widget->setSize(width, height); } } @@ -697,21 +742,16 @@ protected: if (fModal.enabled && fModal.parent != nullptr) exec_fini(); + fSelf->onClose(); + if (fModal.childFocus != nullptr) fModal.childFocus->onClose(); - FOR_EACH_WIDGET(it) - { - Widget* const widget(*it); - widget->onClose(); - } - close(); } // ------------------------------------------------------------------- -private: App& fApp; Window* fSelf; PuglView* fView; @@ -739,8 +779,8 @@ private: ~Modal() { - assert(! enabled); - assert(childFocus == nullptr); + DISTRHO_SAFE_ASSERT(! enabled); + DISTRHO_SAFE_ASSERT(childFocus == nullptr); } } fModal; @@ -751,8 +791,9 @@ private: ::Window xWindow; #elif defined(DISTRHO_OS_MAC) bool fNeedsIdle; + id xWindow; #else - char _dummy; + char _dummy; #endif // ------------------------------------------------------------------- @@ -770,6 +811,11 @@ private: handlePtr->onKeyboard(press, key); } + static void onSpecialCallback(PuglView* view, bool press, PuglKey key) + { + handlePtr->onSpecial(press, static_cast<Key>(key)); + } + static void onMouseCallback(PuglView* view, int button, bool press, int x, int y) { handlePtr->onMouse(button, press, x, y); @@ -785,11 +831,6 @@ private: handlePtr->onScroll(x, y, dx, dy); } - static void onSpecialCallback(PuglView* view, bool press, PuglKey key) - { - handlePtr->onSpecial(press, static_cast<Key>(key)); - } - static void onReshapeCallback(PuglView* view, int width, int height) { handlePtr->onReshape(width, height); @@ -807,19 +848,13 @@ private: // Window Window::Window(App& app) - : pData(new PrivateData(app, this)) -{ -} + : pData(new PrivateData(app, this)) {} Window::Window(App& app, Window& parent) - : pData(new PrivateData(app, this, parent)) -{ -} + : pData(new PrivateData(app, this, parent)) {} Window::Window(App& app, intptr_t parentId) - : pData(new PrivateData(app, this, parentId)) -{ -} + : pData(new PrivateData(app, this, parentId)) {} Window::~Window() { @@ -851,14 +886,14 @@ void Window::focus() pData->focus(); } -void Window::repaint() +void Window::repaint() noexcept { - pData->repaint(); + puglPostRedisplay(pData->fView); } bool Window::isVisible() const noexcept { - return pData->isVisible(); + return pData->fVisible; } void Window::setVisible(bool yesNo) @@ -868,7 +903,7 @@ void Window::setVisible(bool yesNo) bool Window::isResizable() const noexcept { - return pData->isResizable(); + return pData->fResizable; } void Window::setResizable(bool yesNo) @@ -878,24 +913,31 @@ void Window::setResizable(bool yesNo) int Window::getWidth() const noexcept { - return pData->getWidth(); + return pData->fView->width; } int Window::getHeight() const noexcept { - return pData->getHeight(); + return pData->fView->height; } -Size<int> Window::getSize() const noexcept +Size<uint> Window::getSize() const noexcept { - return pData->getSize(); + DISTRHO_SAFE_ASSERT_RETURN(pData->fView->width >= 0 && pData->fView->height >= 0, Size<uint>(0, 0)); + + return Size<uint>(pData->fView->width, pData->fView->height); } -void Window::setSize(unsigned int width, unsigned int height) +void Window::setSize(uint width, uint height) { pData->setSize(width, height); } +void Window::setSize(Size<uint> size) +{ + pData->setSize(size.getWidth(), size.getHeight()); +} + void Window::setTitle(const char* title) { pData->setTitle(title); @@ -908,22 +950,12 @@ void Window::setTransientWinId(intptr_t winId) App& Window::getApp() const noexcept { - return pData->getApp(); -} - -int Window::getModifiers() const -{ - return pData->getModifiers(); -} - -uint32_t Window::getEventTimestamp() const -{ - return pData->getEventTimestamp(); + return pData->fApp; } -intptr_t Window::getWindowId() const +intptr_t Window::getWindowId() const noexcept { - return pData->getWindowId(); + return puglGetNativeWindow(pData->fView); } void Window::_addWidget(Widget* const widget) @@ -943,6 +975,50 @@ void Window::_idle() // ----------------------------------------------------------------------- +void Window::addIdleCallback(IdleCallback* const callback) +{ + DISTRHO_SAFE_ASSERT_RETURN(callback != nullptr,) + + pData->fApp.pData->idleCallbacks.push_back(callback); +} + +void Window::removeIdleCallback(IdleCallback* const callback) +{ + DISTRHO_SAFE_ASSERT_RETURN(callback != nullptr,) + + pData->fApp.pData->idleCallbacks.remove(callback); +} + +// ----------------------------------------------------------------------- + +void Window::onDisplayBefore() +{ + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glLoadIdentity(); +} + +void Window::onDisplayAfter() +{ +} + +void Window::onReshape(int width, int height) +{ + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(0, width, height, 0, 0.0f, 1.0f); + glViewport(0, 0, width, height); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); +} + +void Window::onClose() +{ +} + +// ----------------------------------------------------------------------- + END_NAMESPACE_DGL #undef DBG diff --git a/libs/dgl/src/Window.mm b/libs/dgl/src/Window.mm new file mode 100644 index 0000000..9d3e0b1 --- /dev/null +++ b/libs/dgl/src/Window.mm @@ -0,0 +1,17 @@ +/* + * DISTRHO Plugin Framework (DPF) + * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com> + * + * Permission to use, copy, modify, and/or distribute this software for any purpose with + * or without fee is hereby granted, provided that the above copyright notice and this + * permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD + * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN + * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER + * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "Window.cpp" diff --git a/libs/dgl/src/nanovg/LICENSE.txt b/libs/dgl/src/nanovg/LICENSE.txt new file mode 100644 index 0000000..2a03a1a --- /dev/null +++ b/libs/dgl/src/nanovg/LICENSE.txt @@ -0,0 +1,18 @@ +Copyright (c) 2013 Mikko Mononen memon@inside.org
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+claim that you wrote the original software. If you use this software
+in a product, an acknowledgment in the product documentation would be
+appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+
diff --git a/libs/dgl/src/nanovg/fontstash.h b/libs/dgl/src/nanovg/fontstash.h new file mode 100644 index 0000000..7fb8955 --- /dev/null +++ b/libs/dgl/src/nanovg/fontstash.h @@ -0,0 +1,1673 @@ +// +// Copyright (c) 2009-2013 Mikko Mononen memon@inside.org +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. +// + +#ifndef FONS_H +#define FONS_H + +#define FONS_INVALID -1 + +enum FONSflags { + FONS_ZERO_TOPLEFT = 1, + FONS_ZERO_BOTTOMLEFT = 2, +}; + +enum FONSalign { + // Horizontal align + FONS_ALIGN_LEFT = 1<<0, // Default + FONS_ALIGN_CENTER = 1<<1, + FONS_ALIGN_RIGHT = 1<<2, + // Vertical align + FONS_ALIGN_TOP = 1<<3, + FONS_ALIGN_MIDDLE = 1<<4, + FONS_ALIGN_BOTTOM = 1<<5, + FONS_ALIGN_BASELINE = 1<<6, // Default +}; + +enum FONSerrorCode { + // Font atlas is full. + FONS_ATLAS_FULL = 1, + // Scratch memory used to render glyphs is full, requested size reported in 'val', you may need to bump up FONS_SCRATCH_BUF_SIZE. + FONS_SCRATCH_FULL = 2, + // Calls to fonsPushState has craeted too large stack, if you need deep state stack bump up FONS_MAX_STATES. + FONS_STATES_OVERFLOW = 3, + // Trying to pop too many states fonsPopState(). + FONS_STATES_UNDERFLOW = 4, +}; + +struct FONSparams { + int width, height; + unsigned char flags; + void* userPtr; + int (*renderCreate)(void* uptr, int width, int height); + int (*renderResize)(void* uptr, int width, int height); + void (*renderUpdate)(void* uptr, int* rect, const unsigned char* data); + void (*renderDraw)(void* uptr, const float* verts, const float* tcoords, const unsigned int* colors, int nverts); + void (*renderDelete)(void* uptr); +}; + +struct FONSquad +{ + float x0,y0,s0,t0; + float x1,y1,s1,t1; +}; + +struct FONStextIter { + float x, y, nextx, nexty, scale, spacing; + unsigned int codepoint; + short isize, iblur; + struct FONSfont* font; + struct FONSglyph* prevGlyph; + const char* str; + const char* next; + const char* end; + unsigned int utf8state; +}; + +// Contructor and destructor. +struct FONScontext* fonsCreateInternal(struct FONSparams* params); +void fonsDeleteInternal(struct FONScontext* s); + +void fonsSetErrorCallback(struct FONScontext* s, void (*callback)(void* uptr, int error, int val), void* uptr); +// Returns current atlas size. +void fonsGetAtlasSize(struct FONScontext* s, int* width, int* height); +// Expands the atlas size. +int fonsExpandAtlas(struct FONScontext* s, int width, int height); +// Reseta the whole stash. +int fonsResetAtlas(struct FONScontext* stash, int width, int height); + +// Add fonts +int fonsAddFont(struct FONScontext* s, const char* name, const char* path); +int fonsAddFontMem(struct FONScontext* s, const char* name, unsigned char* data, int ndata, int freeData); +int fonsGetFontByName(struct FONScontext* s, const char* name); + +// State handling +void fonsPushState(struct FONScontext* s); +void fonsPopState(struct FONScontext* s); +void fonsClearState(struct FONScontext* s); + +// State setting +void fonsSetSize(struct FONScontext* s, float size); +void fonsSetColor(struct FONScontext* s, unsigned int color); +void fonsSetSpacing(struct FONScontext* s, float spacing); +void fonsSetBlur(struct FONScontext* s, float blur); +void fonsSetAlign(struct FONScontext* s, int align); +void fonsSetFont(struct FONScontext* s, int font); + +// Draw text +float fonsDrawText(struct FONScontext* s, float x, float y, const char* string, const char* end); + +// Measure text +float fonsTextBounds(struct FONScontext* s, float x, float y, const char* string, const char* end, float* bounds); +void fonsLineBounds(struct FONScontext* s, float y, float* miny, float* maxy); +void fonsVertMetrics(struct FONScontext* s, float* ascender, float* descender, float* lineh); + +// Text iterator +int fonsTextIterInit(struct FONScontext* stash, struct FONStextIter* iter, float x, float y, const char* str, const char* end); +int fonsTextIterNext(struct FONScontext* stash, struct FONStextIter* iter, struct FONSquad* quad); + +// Pull texture changes +const unsigned char* fonsGetTextureData(struct FONScontext* stash, int* width, int* height); +int fonsValidateTexture(struct FONScontext* s, int* dirty); + +// Draws the stash texture for debugging +void fonsDrawDebug(struct FONScontext* s, float x, float y); + +#endif // FONS_H + + +#ifdef FONTSTASH_IMPLEMENTATION + +#define FONS_NOTUSED(v) (void)sizeof(v) + +#ifdef FONS_USE_FREETYPE + +#include <ft2build.h> +#include FT_FREETYPE_H +#include FT_ADVANCES_H +#include <math.h> + +struct FONSttFontImpl { + FT_Face font; +}; + +static FT_Library ftLibrary; + +int fons__tt_init() +{ + FT_Error ftError; + ftError = FT_Init_FreeType(&ftLibrary); + return ftError == 0; +} + +int fons__tt_loadFont(struct FONScontext *context, struct FONSttFontImpl *font, unsigned char *data, int dataSize) +{ + FT_Error ftError; + FONS_NOTUSED(context); + + //font->font.userdata = stash; + ftError = FT_New_Memory_Face(ftLibrary, (const FT_Byte*)data, dataSize, 0, &font->font); + return ftError == 0; +} + +void fons__tt_getFontVMetrics(struct FONSttFontImpl *font, int *ascent, int *descent, int *lineGap) +{ + *ascent = font->font->ascender; + *descent = font->font->descender; + *lineGap = font->font->height - (*ascent - *descent); +} + +float fons__tt_getPixelHeightScale(struct FONSttFontImpl *font, float size) +{ + return size / (font->font->ascender - font->font->descender); +} + +int fons__tt_getGlyphIndex(struct FONSttFontImpl *font, int codepoint) +{ + return FT_Get_Char_Index(font->font, codepoint); +} + +int fons__tt_buildGlyphBitmap(struct FONSttFontImpl *font, int glyph, float size, float scale, int *advance, int *lsb, int *x0, int *y0, int *x1, int *y1) +{ + FT_Error ftError; + FT_GlyphSlot ftGlyph; + FONS_NOTUSED(scale); + + ftError = FT_Set_Pixel_Sizes(font->font, 0, (FT_UInt)(size * (float)font->font->units_per_EM / (float)(font->font->ascender - font->font->descender))); + if (ftError) return 0; + ftError = FT_Load_Glyph(font->font, glyph, FT_LOAD_RENDER); + if (ftError) return 0; + ftError = FT_Get_Advance(font->font, glyph, FT_LOAD_NO_SCALE, (FT_Fixed*)advance); + if (ftError) return 0; + ftGlyph = font->font->glyph; + *lsb = ftGlyph->metrics.horiBearingX; + *x0 = ftGlyph->bitmap_left; + *x1 = *x0 + ftGlyph->bitmap.width; + *y0 = -ftGlyph->bitmap_top; + *y1 = *y0 + ftGlyph->bitmap.rows; + return 1; +} + +void fons__tt_renderGlyphBitmap(struct FONSttFontImpl *font, unsigned char *output, int outWidth, int outHeight, int outStride, float scaleX, float scaleY, int glyph) +{ + FT_GlyphSlot ftGlyph = font->font->glyph; + int ftGlyphOffset = 0; + int x, y; + FONS_NOTUSED(outWidth); + FONS_NOTUSED(outHeight); + FONS_NOTUSED(scaleX); + FONS_NOTUSED(scaleY); + FONS_NOTUSED(glyph); // glyph has already been loaded by fons__tt_buildGlyphBitmap + + for ( y = 0; y < ftGlyph->bitmap.rows; y++ ) { + for ( x = 0; x < ftGlyph->bitmap.width; x++ ) { + output[(y * outStride) + x] = ftGlyph->bitmap.buffer[ftGlyphOffset++]; + } + } +} + +int fons__tt_getGlyphKernAdvance(struct FONSttFontImpl *font, int glyph1, int glyph2) +{ + FT_Vector ftKerning; + FT_Get_Kerning(font->font, glyph1, glyph2, FT_KERNING_DEFAULT, &ftKerning); + return ftKerning.x; +} + +#else + +#define STB_TRUETYPE_IMPLEMENTATION +static void* fons__tmpalloc(size_t size, void* up); +static void fons__tmpfree(void* ptr, void* up); +#define STBTT_malloc(x,u) fons__tmpalloc(x,u) +#define STBTT_free(x,u) fons__tmpfree(x,u) +#include "stb_truetype.h" + +struct FONSttFontImpl { + stbtt_fontinfo font; +}; + +int fons__tt_init(struct FONScontext *context) +{ + FONS_NOTUSED(context); + return 1; +} + +int fons__tt_loadFont(struct FONScontext *context, struct FONSttFontImpl *font, unsigned char *data, int dataSize) +{ + int stbError; + FONS_NOTUSED(dataSize); + + font->font.userdata = context; + stbError = stbtt_InitFont(&font->font, data, 0); + return stbError; +} + +void fons__tt_getFontVMetrics(struct FONSttFontImpl *font, int *ascent, int *descent, int *lineGap) +{ + stbtt_GetFontVMetrics(&font->font, ascent, descent, lineGap); +} + +float fons__tt_getPixelHeightScale(struct FONSttFontImpl *font, float size) +{ + return stbtt_ScaleForPixelHeight(&font->font, size); +} + +int fons__tt_getGlyphIndex(struct FONSttFontImpl *font, int codepoint) +{ + return stbtt_FindGlyphIndex(&font->font, codepoint); +} + +int fons__tt_buildGlyphBitmap(struct FONSttFontImpl *font, int glyph, float size, float scale, int *advance, int *lsb, int *x0, int *y0, int *x1, int *y1) +{ + FONS_NOTUSED(size); + stbtt_GetGlyphHMetrics(&font->font, glyph, advance, lsb); + stbtt_GetGlyphBitmapBox(&font->font, glyph, scale, scale, x0, y0, x1, y1); + return 1; +} + +void fons__tt_renderGlyphBitmap(struct FONSttFontImpl *font, unsigned char *output, int outWidth, int outHeight, int outStride, float scaleX, float scaleY, int glyph) +{ + stbtt_MakeGlyphBitmap(&font->font, output, outWidth, outHeight, outStride, scaleX, scaleY, glyph); +} + +int fons__tt_getGlyphKernAdvance(struct FONSttFontImpl *font, int glyph1, int glyph2) +{ + return stbtt_GetGlyphKernAdvance(&font->font, glyph1, glyph2); +} + +#endif + +#ifndef FONS_SCRATCH_BUF_SIZE +# define FONS_SCRATCH_BUF_SIZE 16000 +#endif +#ifndef FONS_HASH_LUT_SIZE +# define FONS_HASH_LUT_SIZE 256 +#endif +#ifndef FONS_INIT_FONTS +# define FONS_INIT_FONTS 4 +#endif +#ifndef FONS_INIT_GLYPHS +# define FONS_INIT_GLYPHS 256 +#endif +#ifndef FONS_INIT_ATLAS_NODES +# define FONS_INIT_ATLAS_NODES 256 +#endif +#ifndef FONS_VERTEX_COUNT +# define FONS_VERTEX_COUNT 1024 +#endif +#ifndef FONS_MAX_STATES +# define FONS_MAX_STATES 20 +#endif + +static unsigned int fons__hashint(unsigned int a) +{ + a += ~(a<<15); + a ^= (a>>10); + a += (a<<3); + a ^= (a>>6); + a += ~(a<<11); + a ^= (a>>16); + return a; +} + +static int fons__mini(int a, int b) +{ + return a < b ? a : b; +} + +static int fons__maxi(int a, int b) +{ + return a > b ? a : b; +} + +struct FONSglyph +{ + unsigned int codepoint; + int index; + int next; + short size, blur; + short x0,y0,x1,y1; + short xadv,xoff,yoff; +}; + +struct FONSfont +{ + struct FONSttFontImpl font; + char name[64]; + unsigned char* data; + int dataSize; + unsigned char freeData; + float ascender; + float descender; + float lineh; + struct FONSglyph* glyphs; + int cglyphs; + int nglyphs; + int lut[FONS_HASH_LUT_SIZE]; +}; + +struct FONSstate +{ + int font; + int align; + float size; + unsigned int color; + float blur; + float spacing; +}; + +struct FONSatlasNode { + short x, y, width; +}; + +struct FONSatlas +{ + int width, height; + struct FONSatlasNode* nodes; + int nnodes; + int cnodes; +}; + +struct FONScontext +{ + struct FONSparams params; + float itw,ith; + unsigned char* texData; + int dirtyRect[4]; + struct FONSfont** fonts; + struct FONSatlas* atlas; + int cfonts; + int nfonts; + float verts[FONS_VERTEX_COUNT*2]; + float tcoords[FONS_VERTEX_COUNT*2]; + unsigned int colors[FONS_VERTEX_COUNT]; + int nverts; + unsigned char *scratch; + int nscratch; + struct FONSstate states[FONS_MAX_STATES]; + int nstates; + void (*handleError)(void* uptr, int error, int val); + void* errorUptr; +}; + +static void* fons__tmpalloc(size_t size, void* up) +{ + unsigned char* ptr; + struct FONScontext* stash = (struct FONScontext*)up; + + // 16-byte align the returned pointer + size = (size + 0xf) & ~0xf; + + if (stash->nscratch+(int)size > FONS_SCRATCH_BUF_SIZE) { + if (stash->handleError) + stash->handleError(stash->errorUptr, FONS_SCRATCH_FULL, stash->nscratch+(int)size); + return NULL; + } + ptr = stash->scratch + stash->nscratch; + stash->nscratch += (int)size; + return ptr; +} + +static void fons__tmpfree(void* ptr, void* up) +{ + (void)ptr; + (void)up; + // empty +} + +// Copyright (c) 2008-2010 Bjoern Hoehrmann <bjoern@hoehrmann.de> +// See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details. + +#define FONS_UTF8_ACCEPT 0 +#define FONS_UTF8_REJECT 12 + +static unsigned int fons__decutf8(unsigned int* state, unsigned int* codep, unsigned int byte) +{ + static const unsigned char utf8d[] = { + // The first part of the table maps bytes to character classes that + // to reduce the size of the transition table and create bitmasks. + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, + 10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8, + + // The second part is a transition table that maps a combination + // of a state of the automaton and a character class to a state. + 0,12,24,36,60,96,84,12,12,12,48,72, 12,12,12,12,12,12,12,12,12,12,12,12, + 12, 0,12,12,12,12,12, 0,12, 0,12,12, 12,24,12,12,12,12,12,24,12,24,12,12, + 12,12,12,12,12,12,12,24,12,12,12,12, 12,24,12,12,12,12,12,12,12,24,12,12, + 12,12,12,12,12,12,12,36,12,36,12,12, 12,36,12,12,12,12,12,36,12,36,12,12, + 12,36,12,12,12,12,12,12,12,12,12,12, + }; + + unsigned int type = utf8d[byte]; + + *codep = (*state != FONS_UTF8_ACCEPT) ? + (byte & 0x3fu) | (*codep << 6) : + (0xff >> type) & (byte); + + *state = utf8d[256 + *state + type]; + return *state; +} + +// Atlas based on Skyline Bin Packer by Jukka Jylänki + +static void fons__deleteAtlas(struct FONSatlas* atlas) +{ + if (atlas == NULL) return; + if (atlas->nodes != NULL) free(atlas->nodes); + free(atlas); +} + +static struct FONSatlas* fons__allocAtlas(int w, int h, int nnodes) +{ + struct FONSatlas* atlas = NULL; + + // Allocate memory for the font stash. + atlas = (struct FONSatlas*)malloc(sizeof(struct FONSatlas)); + if (atlas == NULL) goto error; + memset(atlas, 0, sizeof(struct FONSatlas)); + + atlas->width = w; + atlas->height = h; + + // Allocate space for skyline nodes + atlas->nodes = (struct FONSatlasNode*)malloc(sizeof(struct FONSatlasNode) * nnodes); + if (atlas->nodes == NULL) goto error; + memset(atlas->nodes, 0, sizeof(struct FONSatlasNode) * nnodes); + atlas->nnodes = 0; + atlas->cnodes = nnodes; + + // Init root node. + atlas->nodes[0].x = 0; + atlas->nodes[0].y = 0; + atlas->nodes[0].width = (short)w; + atlas->nnodes++; + + return atlas; + +error: + if (atlas) fons__deleteAtlas(atlas); + return NULL; +} + +static int fons__atlasInsertNode(struct FONSatlas* atlas, int idx, int x, int y, int w) +{ + int i; + // Insert node + if (atlas->nnodes+1 > atlas->cnodes) { + atlas->cnodes = atlas->cnodes == 0 ? 8 : atlas->cnodes * 2; + atlas->nodes = (struct FONSatlasNode*)realloc(atlas->nodes, sizeof(struct FONSatlasNode) * atlas->cnodes); + if (atlas->nodes == NULL) + return 0; + } + for (i = atlas->nnodes; i > idx; i--) + atlas->nodes[i] = atlas->nodes[i-1]; + atlas->nodes[idx].x = (short)x; + atlas->nodes[idx].y = (short)y; + atlas->nodes[idx].width = (short)w; + atlas->nnodes++; + + return 1; +} + +static void fons__atlasRemoveNode(struct FONSatlas* atlas, int idx) +{ + int i; + if (atlas->nnodes == 0) return; + for (i = idx; i < atlas->nnodes-1; i++) + atlas->nodes[i] = atlas->nodes[i+1]; + atlas->nnodes--; +} + +static void fons__atlasExpand(struct FONSatlas* atlas, int w, int h) +{ + // Insert node for empty space + if (w > atlas->width) + fons__atlasInsertNode(atlas, atlas->nnodes, atlas->width, 0, w - atlas->width); + atlas->width = w; + atlas->height = h; +} + +static void fons__atlasReset(struct FONSatlas* atlas, int w, int h) +{ + atlas->width = w; + atlas->height = h; + atlas->nnodes = 0; + + // Init root node. + atlas->nodes[0].x = 0; + atlas->nodes[0].y = 0; + atlas->nodes[0].width = (short)w; + atlas->nnodes++; +} + +static int fons__atlasAddSkylineLevel(struct FONSatlas* atlas, int idx, int x, int y, int w, int h) +{ + int i; + + // Insert new node + if (fons__atlasInsertNode(atlas, idx, x, y+h, w) == 0) + return 0; + + // Delete skyline segments that fall under the shaodw of the new segment. + for (i = idx+1; i < atlas->nnodes; i++) { + if (atlas->nodes[i].x < atlas->nodes[i-1].x + atlas->nodes[i-1].width) { + int shrink = atlas->nodes[i-1].x + atlas->nodes[i-1].width - atlas->nodes[i].x; + atlas->nodes[i].x += (short)shrink; + atlas->nodes[i].width -= (short)shrink; + if (atlas->nodes[i].width <= 0) { + fons__atlasRemoveNode(atlas, i); + i--; + } else { + break; + } + } else { + break; + } + } + + // Merge same height skyline segments that are next to each other. + for (i = 0; i < atlas->nnodes-1; i++) { + if (atlas->nodes[i].y == atlas->nodes[i+1].y) { + atlas->nodes[i].width += atlas->nodes[i+1].width; + fons__atlasRemoveNode(atlas, i+1); + i--; + } + } + + return 1; +} + +static int fons__atlasRectFits(struct FONSatlas* atlas, int i, int w, int h) +{ + // Checks if there is enough space at the location of skyline span 'i', + // and return the max height of all skyline spans under that at that location, + // (think tetris block being dropped at that position). Or -1 if no space found. + int x = atlas->nodes[i].x; + int y = atlas->nodes[i].y; + int spaceLeft; + if (x + w > atlas->width) + return -1; + spaceLeft = w; + while (spaceLeft > 0) { + if (i == atlas->nnodes) return -1; + y = fons__maxi(y, atlas->nodes[i].y); + if (y + h > atlas->height) return -1; + spaceLeft -= atlas->nodes[i].width; + ++i; + } + return y; +} + +static int fons__atlasAddRect(struct FONSatlas* atlas, int rw, int rh, int* rx, int* ry) +{ + int besth = atlas->height, bestw = atlas->width, besti = -1; + int bestx = -1, besty = -1, i; + + // Bottom left fit heuristic. + for (i = 0; i < atlas->nnodes; i++) { + int y = fons__atlasRectFits(atlas, i, rw, rh); + if (y != -1) { + if (y + rh < besth || (y + rh == besth && atlas->nodes[i].width < bestw)) { + besti = i; + bestw = atlas->nodes[i].width; + besth = y + rh; + bestx = atlas->nodes[i].x; + besty = y; + } + } + } + + if (besti == -1) + return 0; + + // Perform the actual packing. + if (fons__atlasAddSkylineLevel(atlas, besti, bestx, besty, rw, rh) == 0) + return 0; + + *rx = bestx; + *ry = besty; + + return 1; +} + +static void fons__addWhiteRect(struct FONScontext* stash, int w, int h) +{ + int x, y, gx, gy; + unsigned char* dst; + if (fons__atlasAddRect(stash->atlas, w, h, &gx, &gy) == 0) + return; + + // Rasterize + dst = &stash->texData[gx + gy * stash->params.width]; + for (y = 0; y < h; y++) { + for (x = 0; x < w; x++) + dst[x] = 0xff; + dst += stash->params.width; + } + + stash->dirtyRect[0] = fons__mini(stash->dirtyRect[0], gx); + stash->dirtyRect[1] = fons__mini(stash->dirtyRect[1], gy); + stash->dirtyRect[2] = fons__maxi(stash->dirtyRect[2], gx+w); + stash->dirtyRect[3] = fons__maxi(stash->dirtyRect[3], gy+h); +} + +struct FONScontext* fonsCreateInternal(struct FONSparams* params) +{ + struct FONScontext* stash = NULL; + + // Allocate memory for the font stash. + stash = (struct FONScontext*)malloc(sizeof(struct FONScontext)); + if (stash == NULL) goto error; + memset(stash, 0, sizeof(struct FONScontext)); + + stash->params = *params; + + // Allocate scratch buffer. + stash->scratch = (unsigned char*)malloc(FONS_SCRATCH_BUF_SIZE); + if (stash->scratch == NULL) goto error; + + // Initialize implementation library + if (!fons__tt_init(stash)) goto error; + + if (stash->params.renderCreate != NULL) { + if (stash->params.renderCreate(stash->params.userPtr, stash->params.width, stash->params.height) == 0) + goto error; + } + + stash->atlas = fons__allocAtlas(stash->params.width, stash->params.height, FONS_INIT_ATLAS_NODES); + if (stash->atlas == NULL) goto error; + + // Allocate space for fonts. + stash->fonts = (struct FONSfont**)malloc(sizeof(struct FONSfont*) * FONS_INIT_FONTS); + if (stash->fonts == NULL) goto error; + memset(stash->fonts, 0, sizeof(struct FONSfont*) * FONS_INIT_FONTS); + stash->cfonts = FONS_INIT_FONTS; + stash->nfonts = 0; + + // Create texture for the cache. + stash->itw = 1.0f/stash->params.width; + stash->ith = 1.0f/stash->params.height; + stash->texData = (unsigned char*)malloc(stash->params.width * stash->params.height); + if (stash->texData == NULL) goto error; + memset(stash->texData, 0, stash->params.width * stash->params.height); + + stash->dirtyRect[0] = stash->params.width; + stash->dirtyRect[1] = stash->params.height; + stash->dirtyRect[2] = 0; + stash->dirtyRect[3] = 0; + + // Add white rect at 0,0 for debug drawing. + fons__addWhiteRect(stash, 2,2); + + fonsPushState(stash); + fonsClearState(stash); + + return stash; + +error: + fonsDeleteInternal(stash); + return NULL; +} + +static struct FONSstate* fons__getState(struct FONScontext* stash) +{ + return &stash->states[stash->nstates-1]; +} + +void fonsSetSize(struct FONScontext* stash, float size) +{ + fons__getState(stash)->size = size; +} + +void fonsSetColor(struct FONScontext* stash, unsigned int color) +{ + fons__getState(stash)->color = color; +} + +void fonsSetSpacing(struct FONScontext* stash, float spacing) +{ + fons__getState(stash)->spacing = spacing; +} + +void fonsSetBlur(struct FONScontext* stash, float blur) +{ + fons__getState(stash)->blur = blur; +} + +void fonsSetAlign(struct FONScontext* stash, int align) +{ + fons__getState(stash)->align = align; +} + +void fonsSetFont(struct FONScontext* stash, int font) +{ + fons__getState(stash)->font = font; +} + +void fonsPushState(struct FONScontext* stash) +{ + if (stash->nstates >= FONS_MAX_STATES) { + if (stash->handleError) + stash->handleError(stash->errorUptr, FONS_STATES_OVERFLOW, 0); + return; + } + if (stash->nstates > 0) + memcpy(&stash->states[stash->nstates], &stash->states[stash->nstates-1], sizeof(struct FONSstate)); + stash->nstates++; +} + +void fonsPopState(struct FONScontext* stash) +{ + if (stash->nstates <= 1) { + if (stash->handleError) + stash->handleError(stash->errorUptr, FONS_STATES_UNDERFLOW, 0); + return; + } + stash->nstates--; +} + +void fonsClearState(struct FONScontext* stash) +{ + struct FONSstate* state = fons__getState(stash); + state->size = 12.0f; + state->color = 0xffffffff; + state->font = 0; + state->blur = 0; + state->spacing = 0; + state->align = FONS_ALIGN_LEFT | FONS_ALIGN_BASELINE; +} + +static void fons__freeFont(struct FONSfont* font) +{ + if (font == NULL) return; + if (font->glyphs) free(font->glyphs); + if (font->freeData && font->data) free(font->data); + free(font); +} + +static int fons__allocFont(struct FONScontext* stash) +{ + struct FONSfont* font = NULL; + if (stash->nfonts+1 > stash->cfonts) { + stash->cfonts = stash->cfonts == 0 ? 8 : stash->cfonts * 2; + stash->fonts = (struct FONSfont**)realloc(stash->fonts, sizeof(struct FONSfont*) * stash->cfonts); + if (stash->fonts == NULL) + return -1; + } + font = (struct FONSfont*)malloc(sizeof(struct FONSfont)); + if (font == NULL) goto error; + memset(font, 0, sizeof(struct FONSfont)); + + font->glyphs = (struct FONSglyph*)malloc(sizeof(struct FONSglyph) * FONS_INIT_GLYPHS); + if (font->glyphs == NULL) goto error; + font->cglyphs = FONS_INIT_GLYPHS; + font->nglyphs = 0; + + stash->fonts[stash->nfonts++] = font; + return stash->nfonts-1; + +error: + fons__freeFont(font); + + return FONS_INVALID; +} + +int fonsAddFont(struct FONScontext* stash, const char* name, const char* path) +{ + FILE* fp = 0; + int dataSize = 0; + unsigned char* data = NULL; + size_t r; + + // Read in the font data. + fp = fopen(path, "rb"); + if (!fp) goto error; + fseek(fp,0,SEEK_END); + dataSize = (int)ftell(fp); + fseek(fp,0,SEEK_SET); + data = (unsigned char*)malloc(dataSize); + if (data == NULL) goto error; + r = fread(data, 1, dataSize, fp); + fclose(fp); + fp = 0; + + return fonsAddFontMem(stash, name, data, dataSize, 1); + + NVG_NOTUSED(r); + +error: + if (data) free(data); + if (fp) fclose(fp); + return FONS_INVALID; +} + +int fonsAddFontMem(struct FONScontext* stash, const char* name, unsigned char* data, int dataSize, int freeData) +{ + int i, ascent, descent, fh, lineGap; + struct FONSfont* font; + + int idx = fons__allocFont(stash); + if (idx == FONS_INVALID) + return FONS_INVALID; + + font = stash->fonts[idx]; + + strncpy(font->name, name, sizeof(font->name)); + font->name[sizeof(font->name)-1] = '\0'; + + // Init hash lookup. + for (i = 0; i < FONS_HASH_LUT_SIZE; ++i) + font->lut[i] = -1; + + // Read in the font data. + font->dataSize = dataSize; + font->data = data; + font->freeData = (unsigned char)freeData; + + // Init font + stash->nscratch = 0; + if (!fons__tt_loadFont(stash, &font->font, data, dataSize)) goto error; + + // Store normalized line height. The real line height is got + // by multiplying the lineh by font size. + fons__tt_getFontVMetrics( &font->font, &ascent, &descent, &lineGap); + fh = ascent - descent; + font->ascender = (float)ascent / (float)fh; + font->descender = (float)descent / (float)fh; + font->lineh = (float)(fh + lineGap) / (float)fh; + + return idx; + +error: + fons__freeFont(font); + stash->nfonts--; + return FONS_INVALID; +} + +int fonsGetFontByName(struct FONScontext* s, const char* name) +{ + int i; + for (i = 0; i < s->nfonts; i++) { + if (strcmp(s->fonts[i]->name, name) == 0) + return i; + } + return FONS_INVALID; +} + + +static struct FONSglyph* fons__allocGlyph(struct FONSfont* font) +{ + if (font->nglyphs+1 > font->cglyphs) { + font->cglyphs = font->cglyphs == 0 ? 8 : font->cglyphs * 2; + font->glyphs = (struct FONSglyph*)realloc(font->glyphs, sizeof(struct FONSglyph) * font->cglyphs); + if (font->glyphs == NULL) return NULL; + } + font->nglyphs++; + return &font->glyphs[font->nglyphs-1]; +} + + +// Based on Exponential blur, Jani Huhtanen, 2006 + +#define APREC 16 +#define ZPREC 7 + +static void fons__blurCols(unsigned char* dst, int w, int h, int dstStride, int alpha) +{ + int x, y; + for (y = 0; y < h; y++) { + int z = 0; // force zero border + for (x = 1; x < w; x++) { + z += (alpha * (((int)(dst[x]) << ZPREC) - z)) >> APREC; + dst[x] = (unsigned char)(z >> ZPREC); + } + dst[w-1] = 0; // force zero border + z = 0; + for (x = w-2; x >= 0; x--) { + z += (alpha * (((int)(dst[x]) << ZPREC) - z)) >> APREC; + dst[x] = (unsigned char)(z >> ZPREC); + } + dst[0] = 0; // force zero border + dst += dstStride; + } +} + +static void fons__blurRows(unsigned char* dst, int w, int h, int dstStride, int alpha) +{ + int x, y; + for (x = 0; x < w; x++) { + int z = 0; // force zero border + for (y = dstStride; y < h*dstStride; y += dstStride) { + z += (alpha * (((int)(dst[y]) << ZPREC) - z)) >> APREC; + dst[y] = (unsigned char)(z >> ZPREC); + } + dst[(h-1)*dstStride] = 0; // force zero border + z = 0; + for (y = (h-2)*dstStride; y >= 0; y -= dstStride) { + z += (alpha * (((int)(dst[y]) << ZPREC) - z)) >> APREC; + dst[y] = (unsigned char)(z >> ZPREC); + } + dst[0] = 0; // force zero border + dst++; + } +} + + +static void fons__blur(struct FONScontext* stash, unsigned char* dst, int w, int h, int dstStride, int blur) +{ + int alpha; + float sigma; + (void)stash; + + if (blur < 1) + return; + // Calculate the alpha such that 90% of the kernel is within the radius. (Kernel extends to infinity) + sigma = (float)blur * 0.57735f; // 1 / sqrt(3) + alpha = (int)((1<<APREC) * (1.0f - expf(-2.3f / (sigma+1.0f)))); + fons__blurRows(dst, w, h, dstStride, alpha); + fons__blurCols(dst, w, h, dstStride, alpha); + fons__blurRows(dst, w, h, dstStride, alpha); + fons__blurCols(dst, w, h, dstStride, alpha); +// fons__blurrows(dst, w, h, dstStride, alpha); +// fons__blurcols(dst, w, h, dstStride, alpha); +} + +static struct FONSglyph* fons__getGlyph(struct FONScontext* stash, struct FONSfont* font, unsigned int codepoint, + short isize, short iblur) +{ + int i, g, advance, lsb, x0, y0, x1, y1, gw, gh, gx, gy, x, y; + float scale; + struct FONSglyph* glyph = NULL; + unsigned int h; + float size = isize/10.0f; + int pad, added; + unsigned char* bdst; + unsigned char* dst; + + if (isize < 2) return NULL; + if (iblur > 20) iblur = 20; + pad = iblur+2; + + // Reset allocator. + stash->nscratch = 0; + + // Find code point and size. + h = fons__hashint(codepoint) & (FONS_HASH_LUT_SIZE-1); + i = font->lut[h]; + while (i != -1) { + if (font->glyphs[i].codepoint == codepoint && font->glyphs[i].size == isize && font->glyphs[i].blur == iblur) + return &font->glyphs[i]; + i = font->glyphs[i].next; + } + + // Could not find glyph, create it. + scale = fons__tt_getPixelHeightScale(&font->font, size); + g = fons__tt_getGlyphIndex(&font->font, codepoint); + fons__tt_buildGlyphBitmap(&font->font, g, size, scale, &advance, &lsb, &x0, &y0, &x1, &y1); + gw = x1-x0 + pad*2; + gh = y1-y0 + pad*2; + + // Find free spot for the rect in the atlas + added = fons__atlasAddRect(stash->atlas, gw, gh, &gx, &gy); + if (added == 0 && stash->handleError != NULL) { + // Atlas is full, let the user to resize the atlas (or not), and try again. + stash->handleError(stash->errorUptr, FONS_ATLAS_FULL, 0); + added = fons__atlasAddRect(stash->atlas, gw, gh, &gx, &gy); + } + if (added == 0) return NULL; + + // Init glyph. + glyph = fons__allocGlyph(font); + glyph->codepoint = codepoint; + glyph->size = isize; + glyph->blur = iblur; + glyph->index = g; + glyph->x0 = (short)gx; + glyph->y0 = (short)gy; + glyph->x1 = (short)(glyph->x0+gw); + glyph->y1 = (short)(glyph->y0+gh); + glyph->xadv = (short)(scale * advance * 10.0f); + glyph->xoff = (short)(x0 - pad); + glyph->yoff = (short)(y0 - pad); + glyph->next = 0; + + // Insert char to hash lookup. + glyph->next = font->lut[h]; + font->lut[h] = font->nglyphs-1; + + // Rasterize + dst = &stash->texData[(glyph->x0+pad) + (glyph->y0+pad) * stash->params.width]; + fons__tt_renderGlyphBitmap(&font->font, dst, gw-pad*2,gh-pad*2, stash->params.width, scale,scale, g); + + // Make sure there is one pixel empty border. + dst = &stash->texData[glyph->x0 + glyph->y0 * stash->params.width]; + for (y = 0; y < gh; y++) { + dst[y*stash->params.width] = 0; + dst[gw-1 + y*stash->params.width] = 0; + } + for (x = 0; x < gw; x++) { + dst[x] = 0; + dst[x + (gh-1)*stash->params.width] = 0; + } + + // Debug code to color the glyph background +/* unsigned char* fdst = &stash->texData[glyph->x0 + glyph->y0 * stash->params.width]; + for (y = 0; y < gh; y++) { + for (x = 0; x < gw; x++) { + int a = (int)fdst[x+y*stash->params.width] + 20; + if (a > 255) a = 255; + fdst[x+y*stash->params.width] = a; + } + }*/ + + // Blur + if (iblur > 0) { + stash->nscratch = 0; + bdst = &stash->texData[glyph->x0 + glyph->y0 * stash->params.width]; + fons__blur(stash, bdst, gw,gh, stash->params.width, iblur); + } + + stash->dirtyRect[0] = fons__mini(stash->dirtyRect[0], glyph->x0); + stash->dirtyRect[1] = fons__mini(stash->dirtyRect[1], glyph->y0); + stash->dirtyRect[2] = fons__maxi(stash->dirtyRect[2], glyph->x1); + stash->dirtyRect[3] = fons__maxi(stash->dirtyRect[3], glyph->y1); + + return glyph; +} + +static void fons__getQuad(struct FONScontext* stash, struct FONSfont* font, + struct FONSglyph* prevGlyph, struct FONSglyph* glyph, + float scale, float spacing, float* x, float* y, struct FONSquad* q) +{ + float rx,ry,xoff,yoff,x0,y0,x1,y1; + + if (prevGlyph) { + float adv = fons__tt_getGlyphKernAdvance(&font->font, prevGlyph->index, glyph->index) * scale; + *x += (int)(adv + spacing + 0.5f); + } + + // Each glyph has 2px border to allow good interpolation, + // one pixel to prevent leaking, and one to allow good interpolation for rendering. + // Inset the texture region by one pixel for corret interpolation. + xoff = (short)(glyph->xoff+1); + yoff = (short)(glyph->yoff+1); + x0 = (float)(glyph->x0+1); + y0 = (float)(glyph->y0+1); + x1 = (float)(glyph->x1-1); + y1 = (float)(glyph->y1-1); + + if (stash->params.flags & FONS_ZERO_TOPLEFT) { + rx = (float)(int)(*x + xoff); + ry = (float)(int)(*y + yoff); + + q->x0 = rx; + q->y0 = ry; + q->x1 = rx + x1 - x0; + q->y1 = ry + y1 - y0; + + q->s0 = x0 * stash->itw; + q->t0 = y0 * stash->ith; + q->s1 = x1 * stash->itw; + q->t1 = y1 * stash->ith; + } else { + rx = (float)(int)(*x + xoff); + ry = (float)(int)(*y - yoff); + + q->x0 = rx; + q->y0 = ry; + q->x1 = rx + x1 - x0; + q->y1 = ry - y1 + y0; + + q->s0 = x0 * stash->itw; + q->t0 = y0 * stash->ith; + q->s1 = x1 * stash->itw; + q->t1 = y1 * stash->ith; + } + + *x += (int)(glyph->xadv / 10.0f + 0.5f); +} + +static void fons__flush(struct FONScontext* stash) +{ + // Flush texture + if (stash->dirtyRect[0] < stash->dirtyRect[2] && stash->dirtyRect[1] < stash->dirtyRect[3]) { + if (stash->params.renderUpdate != NULL) + stash->params.renderUpdate(stash->params.userPtr, stash->dirtyRect, stash->texData); + // Reset dirty rect + stash->dirtyRect[0] = stash->params.width; + stash->dirtyRect[1] = stash->params.height; + stash->dirtyRect[2] = 0; + stash->dirtyRect[3] = 0; + } + + // Flush triangles + if (stash->nverts > 0) { + if (stash->params.renderDraw != NULL) + stash->params.renderDraw(stash->params.userPtr, stash->verts, stash->tcoords, stash->colors, stash->nverts); + stash->nverts = 0; + } +} + +static __inline void fons__vertex(struct FONScontext* stash, float x, float y, float s, float t, unsigned int c) +{ + stash->verts[stash->nverts*2+0] = x; + stash->verts[stash->nverts*2+1] = y; + stash->tcoords[stash->nverts*2+0] = s; + stash->tcoords[stash->nverts*2+1] = t; + stash->colors[stash->nverts] = c; + stash->nverts++; +} + +static float fons__getVertAlign(struct FONScontext* stash, struct FONSfont* font, int align, short isize) +{ + if (stash->params.flags & FONS_ZERO_TOPLEFT) { + if (align & FONS_ALIGN_TOP) { + return font->ascender * (float)isize/10.0f; + } else if (align & FONS_ALIGN_MIDDLE) { + return (font->ascender + font->descender) / 2.0f * (float)isize/10.0f; + } else if (align & FONS_ALIGN_BASELINE) { + return 0.0f; + } else if (align & FONS_ALIGN_BOTTOM) { + return font->descender * (float)isize/10.0f; + } + } else { + if (align & FONS_ALIGN_TOP) { + return -font->ascender * (float)isize/10.0f; + } else if (align & FONS_ALIGN_MIDDLE) { + return -(font->ascender + font->descender) / 2.0f * (float)isize/10.0f; + } else if (align & FONS_ALIGN_BASELINE) { + return 0.0f; + } else if (align & FONS_ALIGN_BOTTOM) { + return -font->descender * (float)isize/10.0f; + } + } + return 0.0; +} + +float fonsDrawText(struct FONScontext* stash, + float x, float y, + const char* str, const char* end) +{ + struct FONSstate* state = fons__getState(stash); + unsigned int codepoint; + unsigned int utf8state = 0; + struct FONSglyph* glyph = NULL; + struct FONSglyph* prevGlyph = NULL; + struct FONSquad q; + short isize = (short)(state->size*10.0f); + short iblur = (short)state->blur; + float scale; + struct FONSfont* font; + float width; + + if (stash == NULL) return x; + if (state->font < 0 || state->font >= stash->nfonts) return x; + font = stash->fonts[state->font]; + if (!font->data) return x; + + scale = fons__tt_getPixelHeightScale(&font->font, (float)isize/10.0f); + + if (end == NULL) + end = str + strlen(str); + + // Align horizontally + if (state->align & FONS_ALIGN_LEFT) { + // empty + } else if (state->align & FONS_ALIGN_RIGHT) { + width = fonsTextBounds(stash, x,y, str, end, NULL); + x -= width; + } else if (state->align & FONS_ALIGN_CENTER) { + width = fonsTextBounds(stash, x,y, str, end, NULL); + x -= width * 0.5f; + } + // Align vertically. + y += fons__getVertAlign(stash, font, state->align, isize); + + for (; str != end; ++str) { + if (fons__decutf8(&utf8state, &codepoint, *(const unsigned char*)str)) + continue; + glyph = fons__getGlyph(stash, font, codepoint, isize, iblur); + if (glyph) { + fons__getQuad(stash, font, prevGlyph, glyph, scale, state->spacing, &x, &y, &q); + + if (stash->nverts+6 > FONS_VERTEX_COUNT) + fons__flush(stash); + + fons__vertex(stash, q.x0, q.y0, q.s0, q.t0, state->color); + fons__vertex(stash, q.x1, q.y1, q.s1, q.t1, state->color); + fons__vertex(stash, q.x1, q.y0, q.s1, q.t0, state->color); + + fons__vertex(stash, q.x0, q.y0, q.s0, q.t0, state->color); + fons__vertex(stash, q.x0, q.y1, q.s0, q.t1, state->color); + fons__vertex(stash, q.x1, q.y1, q.s1, q.t1, state->color); + } + prevGlyph = glyph; + } + fons__flush(stash); + + return x; +} + +int fonsTextIterInit(struct FONScontext* stash, struct FONStextIter* iter, + float x, float y, const char* str, const char* end) +{ + struct FONSstate* state = fons__getState(stash); + float width; + + memset(iter, 0, sizeof(*iter)); + + if (stash == NULL) return 0; + if (state->font < 0 || state->font >= stash->nfonts) return 0; + iter->font = stash->fonts[state->font]; + if (!iter->font->data) return 0; + + iter->isize = (short)(state->size*10.0f); + iter->iblur = (short)state->blur; + iter->scale = fons__tt_getPixelHeightScale(&iter->font->font, (float)iter->isize/10.0f); + + // Align horizontally + if (state->align & FONS_ALIGN_LEFT) { + // empty + } else if (state->align & FONS_ALIGN_RIGHT) { + width = fonsTextBounds(stash, x,y, str, end, NULL); + x -= width; + } else if (state->align & FONS_ALIGN_CENTER) { + width = fonsTextBounds(stash, x,y, str, end, NULL); + x -= width * 0.5f; + } + // Align vertically. + y += fons__getVertAlign(stash, iter->font, state->align, iter->isize); + + if (end == NULL) + end = str + strlen(str); + + iter->x = iter->nextx = x; + iter->y = iter->nexty = y; + iter->spacing = state->spacing; + iter->str = str; + iter->next = str; + iter->end = end; + iter->codepoint = 0; + + return 1; +} + +int fonsTextIterNext(struct FONScontext* stash, struct FONStextIter* iter, struct FONSquad* quad) +{ + struct FONSglyph* glyph = NULL; + const char* str = iter->next; + iter->str = iter->next; + + if (str == iter->end) + return 0; + + for (; str != iter->end; str++) { + if (fons__decutf8(&iter->utf8state, &iter->codepoint, *(const unsigned char*)str)) + continue; + str++; + // Get glyph and quad + iter->x = iter->nextx; + iter->y = iter->nexty; + glyph = fons__getGlyph(stash, iter->font, iter->codepoint, iter->isize, iter->iblur); + if (glyph != NULL) + fons__getQuad(stash, iter->font, iter->prevGlyph, glyph, iter->scale, iter->spacing, &iter->nextx, &iter->nexty, quad); + iter->prevGlyph = glyph; + break; + } + iter->next = str; + + return 1; +} + +void fonsDrawDebug(struct FONScontext* stash, float x, float y) +{ + int i; + int w = stash->params.width; + int h = stash->params.height; + float u = w == 0 ? 0 : (1.0f / w); + float v = h == 0 ? 0 : (1.0f / h); + + if (stash->nverts+6+6 > FONS_VERTEX_COUNT) + fons__flush(stash); + + // Draw background + fons__vertex(stash, x+0, y+0, u, v, 0x0fffffff); + fons__vertex(stash, x+w, y+h, u, v, 0x0fffffff); + fons__vertex(stash, x+w, y+0, u, v, 0x0fffffff); + + fons__vertex(stash, x+0, y+0, u, v, 0x0fffffff); + fons__vertex(stash, x+0, y+h, u, v, 0x0fffffff); + fons__vertex(stash, x+w, y+h, u, v, 0x0fffffff); + + // Draw texture + fons__vertex(stash, x+0, y+0, 0, 0, 0xffffffff); + fons__vertex(stash, x+w, y+h, 1, 1, 0xffffffff); + fons__vertex(stash, x+w, y+0, 1, 0, 0xffffffff); + + fons__vertex(stash, x+0, y+0, 0, 0, 0xffffffff); + fons__vertex(stash, x+0, y+h, 0, 1, 0xffffffff); + fons__vertex(stash, x+w, y+h, 1, 1, 0xffffffff); + + // Drawbug draw atlas + for (i = 0; i < stash->atlas->nnodes; i++) { + struct FONSatlasNode* n = &stash->atlas->nodes[i]; + + if (stash->nverts+6 > FONS_VERTEX_COUNT) + fons__flush(stash); + + fons__vertex(stash, x+n->x+0, y+n->y+0, u, v, 0xc00000ff); + fons__vertex(stash, x+n->x+n->width, y+n->y+1, u, v, 0xc00000ff); + fons__vertex(stash, x+n->x+n->width, y+n->y+0, u, v, 0xc00000ff); + + fons__vertex(stash, x+n->x+0, y+n->y+0, u, v, 0xc00000ff); + fons__vertex(stash, x+n->x+0, y+n->y+1, u, v, 0xc00000ff); + fons__vertex(stash, x+n->x+n->width, y+n->y+1, u, v, 0xc00000ff); + } + + fons__flush(stash); +} + +float fonsTextBounds(struct FONScontext* stash, + float x, float y, + const char* str, const char* end, + float* bounds) +{ + struct FONSstate* state = fons__getState(stash); + unsigned int codepoint; + unsigned int utf8state = 0; + struct FONSquad q; + struct FONSglyph* glyph = NULL; + struct FONSglyph* prevGlyph = NULL; + short isize = (short)(state->size*10.0f); + short iblur = (short)state->blur; + float scale; + struct FONSfont* font; + float startx, advance; + float minx, miny, maxx, maxy; + + if (stash == NULL) return 0; + if (state->font < 0 || state->font >= stash->nfonts) return 0; + font = stash->fonts[state->font]; + if (!font->data) return 0; + + scale = fons__tt_getPixelHeightScale(&font->font, (float)isize/10.0f); + + // Align vertically. + y += fons__getVertAlign(stash, font, state->align, isize); + + minx = maxx = x; + miny = maxy = y; + startx = x; + + if (end == NULL) + end = str + strlen(str); + + for (; str != end; ++str) { + if (fons__decutf8(&utf8state, &codepoint, *(const unsigned char*)str)) + continue; + glyph = fons__getGlyph(stash, font, codepoint, isize, iblur); + if (glyph) { + fons__getQuad(stash, font, prevGlyph, glyph, scale, state->spacing, &x, &y, &q); + if (q.x0 < minx) minx = q.x0; + if (q.x1 > maxx) maxx = q.x1; + if (stash->params.flags & FONS_ZERO_TOPLEFT) { + if (q.y0 < miny) miny = q.y0; + if (q.y1 > maxy) maxy = q.y1; + } else { + if (q.y1 < miny) miny = q.y1; + if (q.y0 > maxy) maxy = q.y0; + } + } + prevGlyph = glyph; + } + + advance = x - startx; + + // Align horizontally + if (state->align & FONS_ALIGN_LEFT) { + // empty + } else if (state->align & FONS_ALIGN_RIGHT) { + minx -= advance; + maxx -= advance; + } else if (state->align & FONS_ALIGN_CENTER) { + minx -= advance * 0.5f; + maxx -= advance * 0.5f; + } + + if (bounds) { + bounds[0] = minx; + bounds[1] = miny; + bounds[2] = maxx; + bounds[3] = maxy; + } + + return advance; +} + +void fonsVertMetrics(struct FONScontext* stash, + float* ascender, float* descender, float* lineh) +{ + struct FONSfont* font; + struct FONSstate* state = fons__getState(stash); + short isize; + + if (stash == NULL) return; + if (state->font < 0 || state->font >= stash->nfonts) return; + font = stash->fonts[state->font]; + isize = (short)(state->size*10.0f); + if (!font->data) return; + + if (ascender) + *ascender = font->ascender*isize/10.0f; + if (descender) + *descender = font->descender*isize/10.0f; + if (lineh) + *lineh = font->lineh*isize/10.0f; +} + +void fonsLineBounds(struct FONScontext* stash, float y, float* miny, float* maxy) +{ + struct FONSfont* font; + struct FONSstate* state = fons__getState(stash); + short isize; + + if (stash == NULL) return; + if (state->font < 0 || state->font >= stash->nfonts) return; + font = stash->fonts[state->font]; + isize = (short)(state->size*10.0f); + if (!font->data) return; + + y += fons__getVertAlign(stash, font, state->align, isize); + + if (stash->params.flags & FONS_ZERO_TOPLEFT) { + *miny = y - font->ascender * (float)isize/10.0f; + *maxy = *miny + font->lineh*isize/10.0f; + } else { + *maxy = y + font->descender * (float)isize/10.0f; + *miny = *maxy - font->lineh*isize/10.0f; + } +} + +const unsigned char* fonsGetTextureData(struct FONScontext* stash, int* width, int* height) +{ + if (width != NULL) + *width = stash->params.width; + if (height != NULL) + *height = stash->params.height; + return stash->texData; +} + +int fonsValidateTexture(struct FONScontext* stash, int* dirty) +{ + if (stash->dirtyRect[0] < stash->dirtyRect[2] && stash->dirtyRect[1] < stash->dirtyRect[3]) { + dirty[0] = stash->dirtyRect[0]; + dirty[1] = stash->dirtyRect[1]; + dirty[2] = stash->dirtyRect[2]; + dirty[3] = stash->dirtyRect[3]; + // Reset dirty rect + stash->dirtyRect[0] = stash->params.width; + stash->dirtyRect[1] = stash->params.height; + stash->dirtyRect[2] = 0; + stash->dirtyRect[3] = 0; + return 1; + } + return 0; +} + +void fonsDeleteInternal(struct FONScontext* stash) +{ + int i; + if (stash == NULL) return; + + if (stash->params.renderDelete) + stash->params.renderDelete(stash->params.userPtr); + + for (i = 0; i < stash->nfonts; ++i) + fons__freeFont(stash->fonts[i]); + + if (stash->atlas) fons__deleteAtlas(stash->atlas); + if (stash->fonts) free(stash->fonts); + if (stash->texData) free(stash->texData); + if (stash->scratch) free(stash->scratch); + free(stash); +} + +void fonsSetErrorCallback(struct FONScontext* stash, void (*callback)(void* uptr, int error, int val), void* uptr) +{ + if (stash == NULL) return; + stash->handleError = callback; + stash->errorUptr = uptr; +} + +void fonsGetAtlasSize(struct FONScontext* stash, int* width, int* height) +{ + if (stash == NULL) return; + *width = stash->params.width; + *height = stash->params.height; +} + +int fonsExpandAtlas(struct FONScontext* stash, int width, int height) +{ + int i, maxy = 0; + unsigned char* data = NULL; + if (stash == NULL) return 0; + + width = fons__maxi(width, stash->params.width); + height = fons__maxi(height, stash->params.height); + + if (width == stash->params.width && height == stash->params.height) + return 1; + + // Flush pending glyphs. + fons__flush(stash); + + // Create new texture + if (stash->params.renderResize != NULL) { + if (stash->params.renderResize(stash->params.userPtr, width, height) == 0) + return 0; + } + // Copy old texture data over. + data = (unsigned char*)malloc(width * height); + if (data == NULL) + return 0; + for (i = 0; i < stash->params.height; i++) { + unsigned char* dst = &data[i*width]; + unsigned char* src = &stash->texData[i*stash->params.width]; + memcpy(dst, src, stash->params.width); + if (width > stash->params.width) + memset(dst+stash->params.width, 0, width - stash->params.width); + } + if (height > stash->params.height) + memset(&data[stash->params.height * width], 0, (height - stash->params.height) * width); + + free(stash->texData); + stash->texData = data; + + // Increase atlas size + fons__atlasExpand(stash->atlas, width, height); + + // Add axisting data as dirty. + for (i = 0; i < stash->atlas->nnodes; i++) + maxy = fons__maxi(maxy, stash->atlas->nodes[i].y); + stash->dirtyRect[0] = 0; + stash->dirtyRect[1] = 0; + stash->dirtyRect[2] = stash->params.width; + stash->dirtyRect[3] = maxy; + + stash->params.width = width; + stash->params.height = height; + stash->itw = 1.0f/stash->params.width; + stash->ith = 1.0f/stash->params.height; + + return 1; +} + +int fonsResetAtlas(struct FONScontext* stash, int width, int height) +{ + int i, j; + if (stash == NULL) return 0; + + // Flush pending glyphs. + fons__flush(stash); + + // Create new texture + if (stash->params.renderResize != NULL) { + if (stash->params.renderResize(stash->params.userPtr, width, height) == 0) + return 0; + } + + // Reset atlas + fons__atlasReset(stash->atlas, width, height); + + // Clear texture data. + stash->texData = (unsigned char*)realloc(stash->texData, width * height); + if (stash->texData == NULL) return 0; + memset(stash->texData, 0, width * height); + + // Reset dirty rect + stash->dirtyRect[0] = width; + stash->dirtyRect[1] = height; + stash->dirtyRect[2] = 0; + stash->dirtyRect[3] = 0; + + // Reset cached glyphs + for (i = 0; i < stash->nfonts; i++) { + struct FONSfont* font = stash->fonts[i]; + font->nglyphs = 0; + for (j = 0; j < FONS_HASH_LUT_SIZE; j++) + font->lut[j] = -1; + } + + stash->params.width = width; + stash->params.height = height; + stash->itw = 1.0f/stash->params.width; + stash->ith = 1.0f/stash->params.height; + + // Add white rect at 0,0 for debug drawing. + fons__addWhiteRect(stash, 2,2); + + return 1; +} + + +#endif diff --git a/libs/dgl/src/nanovg/nanovg.c b/libs/dgl/src/nanovg/nanovg.c new file mode 100644 index 0000000..0697c9b --- /dev/null +++ b/libs/dgl/src/nanovg/nanovg.c @@ -0,0 +1,2475 @@ +// +// Copyright (c) 2013 Mikko Mononen memon@inside.org +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. +// + +#include <stdio.h> +#include <math.h> +#include "nanovg.h" +#define FONTSTASH_IMPLEMENTATION +#include "fontstash.h" +#include "stb_image.c" + + +#define NVG_INIT_COMMANDS_SIZE 256 +#define NVG_INIT_POINTS_SIZE 128 +#define NVG_INIT_PATHS_SIZE 16 +#define NVG_INIT_VERTS_SIZE 256 +#define NVG_MAX_STATES 32 + +#define NVG_KAPPA90 0.5522847493f // Lenght proportional to radius of a cubic bezier handle for 90deg arcs. + +#define NVG_COUNTOF(arr) (sizeof(arr) / sizeof(0[arr])) + + +enum NVGcommands { + NVG_MOVETO = 0, + NVG_LINETO = 1, + NVG_BEZIERTO = 2, + NVG_CLOSE = 3, + NVG_WINDING = 4, +}; + +enum NVGpointFlags +{ + NVG_PT_CORNER = 0x01, + NVG_PT_LEFT = 0x02, + NVG_PT_BEVEL = 0x04, + NVG_PR_INNERBEVEL = 0x08, +}; + +enum NVGexpandFeatures { + NVG_FILL = 0x01, + NVG_STROKE = 0x02, + NVG_CAPS = 0x04, +}; + +struct NVGstate { + struct NVGpaint fill; + struct NVGpaint stroke; + float strokeWidth; + float miterLimit; + int lineJoin; + int lineCap; + float xform[6]; + struct NVGscissor scissor; + float fontSize; + float letterSpacing; + float lineHeight; + float fontBlur; + int textAlign; + int fontId; +}; + +struct NVGpoint { + float x,y; + float dx, dy; + float len; + float dmx, dmy; + unsigned char flags; +}; + +struct NVGpathCache { + struct NVGpoint* points; + int npoints; + int cpoints; + struct NVGpath* paths; + int npaths; + int cpaths; + struct NVGvertex* verts; + int nverts; + int cverts; + float bounds[4]; +}; + +struct NVGcontext { + struct NVGparams params; + float* commands; + int ccommands; + int ncommands; + float commandx, commandy; + struct NVGstate states[NVG_MAX_STATES]; + int nstates; + struct NVGpathCache* cache; + float tessTol; + float distTol; + float fringeWidth; + float devicePxRatio; + struct FONScontext* fs; + int fontImage; + int alphaBlend; + int drawCallCount; + int fillTriCount; + int strokeTriCount; + int textTriCount; +}; + +static float nvg__sqrtf(float a) { return sqrtf(a); } +static float nvg__modf(float a, float b) { return fmodf(a, b); } +static float nvg__sinf(float a) { return sinf(a); } +static float nvg__cosf(float a) { return cosf(a); } +static float nvg__tanf(float a) { return tanf(a); } +static float nvg__atan2f(float a,float b) { return atan2f(a, b); } +static float nvg__acosf(float a) { return acosf(a); } + +static int nvg__mini(int a, int b) { return a < b ? a : b; } +static int nvg__maxi(int a, int b) { return a > b ? a : b; } +static int nvg__clampi(int a, int mn, int mx) { return a < mn ? mn : (a > mx ? mx : a); } +static float nvg__minf(float a, float b) { return a < b ? a : b; } +static float nvg__maxf(float a, float b) { return a > b ? a : b; } +static float nvg__absf(float a) { return a >= 0.0f ? a : -a; } +static float nvg__clampf(float a, float mn, float mx) { return a < mn ? mn : (a > mx ? mx : a); } +static float nvg__cross(float dx0, float dy0, float dx1, float dy1) { return dx1*dy0 - dx0*dy1; } + +static float nvg__normalize(float *x, float* y) +{ + float d = nvg__sqrtf((*x)*(*x) + (*y)*(*y)); + if (d > 1e-6f) { + float id = 1.0f / d; + *x *= id; + *y *= id; + } + return d; +} + + +static void nvg__deletePathCache(struct NVGpathCache* c) +{ + if (c == NULL) return; + if (c->points != NULL) free(c->points); + if (c->paths != NULL) free(c->paths); + if (c->verts != NULL) free(c->verts); + free(c); +} + +static struct NVGpathCache* nvg__allocPathCache() +{ + struct NVGpathCache* c = (struct NVGpathCache*)malloc(sizeof(struct NVGpathCache)); + if (c == NULL) goto error; + memset(c, 0, sizeof(struct NVGpathCache)); + + c->points = (struct NVGpoint*)malloc(sizeof(struct NVGpoint)*NVG_INIT_POINTS_SIZE); + if (!c->points) goto error; + c->npoints = 0; + c->cpoints = NVG_INIT_POINTS_SIZE; + + c->paths = (struct NVGpath*)malloc(sizeof(struct NVGpath)*NVG_INIT_PATHS_SIZE); + if (!c->paths) goto error; + c->npaths = 0; + c->cpaths = NVG_INIT_PATHS_SIZE; + + c->verts = (struct NVGvertex*)malloc(sizeof(struct NVGvertex)*NVG_INIT_VERTS_SIZE); + if (!c->verts) goto error; + c->nverts = 0; + c->cverts = NVG_INIT_VERTS_SIZE; + + return c; +error: + nvg__deletePathCache(c); + return NULL; +} + +static void nvg__setDevicePixelRatio(struct NVGcontext* ctx, float ratio) +{ + ctx->tessTol = 1.0f / ratio; + ctx->distTol = 0.01f / ratio; + ctx->fringeWidth = 1.0f / ratio; + ctx->devicePxRatio = ratio; +} + +struct NVGcontext* nvgCreateInternal(struct NVGparams* params) +{ + struct FONSparams fontParams; + struct NVGcontext* ctx = (struct NVGcontext*)malloc(sizeof(struct NVGcontext)); + if (ctx == NULL) goto error; + memset(ctx, 0, sizeof(struct NVGcontext)); + + ctx->params = *params; + + ctx->commands = (float*)malloc(sizeof(float)*NVG_INIT_COMMANDS_SIZE); + if (!ctx->commands) goto error; + ctx->ncommands = 0; + ctx->ccommands = NVG_INIT_COMMANDS_SIZE; + + ctx->alphaBlend = NVG_STRAIGHT_ALPHA; + + ctx->cache = nvg__allocPathCache(); + if (ctx->cache == NULL) goto error; + + nvgSave(ctx); + nvgReset(ctx); + + nvg__setDevicePixelRatio(ctx, 1.0f); + + if (ctx->params.renderCreate(ctx->params.userPtr) == 0) goto error; + + // Init font rendering + memset(&fontParams, 0, sizeof(fontParams)); + fontParams.width = params->atlasWidth; + fontParams.height = params->atlasHeight; + fontParams.flags = FONS_ZERO_TOPLEFT; + fontParams.renderCreate = NULL; + fontParams.renderUpdate = NULL; + fontParams.renderDraw = NULL; + fontParams.renderDelete = NULL; + fontParams.userPtr = NULL; + ctx->fs = fonsCreateInternal(&fontParams); + if (ctx->fs == NULL) goto error; + + // Create font texture + ctx->fontImage = ctx->params.renderCreateTexture(ctx->params.userPtr, NVG_TEXTURE_ALPHA, fontParams.width, fontParams.height, NULL); + if (ctx->fontImage == 0) goto error; + + return ctx; + +error: + nvgDeleteInternal(ctx); + return 0; +} + +void nvgDeleteInternal(struct NVGcontext* ctx) +{ + if (ctx == NULL) return; + if (ctx->commands != NULL) free(ctx->commands); + if (ctx->cache != NULL) nvg__deletePathCache(ctx->cache); + + if (ctx->fs) + fonsDeleteInternal(ctx->fs); + + if (ctx->params.renderDelete != NULL) + ctx->params.renderDelete(ctx->params.userPtr); + + free(ctx); +} + +void nvgBeginFrame(struct NVGcontext* ctx, int windowWidth, int windowHeight, float devicePixelRatio, int alphaBlend) +{ +/* printf("Tris: draws:%d fill:%d stroke:%d text:%d TOT:%d\n", + ctx->drawCallCount, ctx->fillTriCount, ctx->strokeTriCount, ctx->textTriCount, + ctx->fillTriCount+ctx->strokeTriCount+ctx->textTriCount);*/ + + ctx->nstates = 0; + nvgSave(ctx); + nvgReset(ctx); + + nvg__setDevicePixelRatio(ctx, devicePixelRatio); + ctx->alphaBlend = alphaBlend; + + ctx->params.renderViewport(ctx->params.userPtr, windowWidth, windowHeight, ctx->alphaBlend); + + ctx->drawCallCount = 0; + ctx->fillTriCount = 0; + ctx->strokeTriCount = 0; + ctx->textTriCount = 0; +} + +void nvgEndFrame(struct NVGcontext* ctx) +{ + ctx->params.renderFlush(ctx->params.userPtr, ctx->alphaBlend); +} + +struct NVGcolor nvgRGB(unsigned char r, unsigned char g, unsigned char b) +{ + return nvgRGBA(r,g,b,255); +} + +struct NVGcolor nvgRGBf(float r, float g, float b) +{ + return nvgRGBAf(r,g,b,1.0f); +} + +struct NVGcolor nvgRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a) +{ + struct NVGcolor color; + // Use longer initialization to suppress warning. + color.r = r / 255.0f; + color.g = g / 255.0f; + color.b = b / 255.0f; + color.a = a / 255.0f; + return color; +} + +struct NVGcolor nvgRGBAf(float r, float g, float b, float a) +{ + struct NVGcolor color; + // Use longer initialization to suppress warning. + color.r = r; + color.g = g; + color.b = b; + color.a = a; + return color; +} + +struct NVGcolor nvgTransRGBA(struct NVGcolor c, unsigned char a) +{ + c.a = a / 255.0f; + return c; +} + +struct NVGcolor nvgTransRGBAf(struct NVGcolor c, float a) +{ + c.a = a; + return c; +} + +struct NVGcolor nvgLerpRGBA(struct NVGcolor c0, struct NVGcolor c1, float u) +{ + int i; + float oneminu; + struct NVGcolor cint; + + u = nvg__clampf(u, 0.0f, 1.0f); + oneminu = 1.0f - u; + for( i = 0; i <4; ++i ) + { + cint.rgba[i] = c0.rgba[i] * oneminu + c1.rgba[i] * u; + } + + return cint; +} + +struct NVGcolor nvgHSL(float h, float s, float l) +{ + return nvgHSLA(h,s,l,255); +} + +static float nvg__hue(float h, float m1, float m2) +{ + if (h < 0) h += 1; + if (h > 1) h -= 1; + if (h < 1.0f/6.0f) + return m1 + (m2 - m1) * h * 6.0f; + else if (h < 3.0f/6.0f) + return m2; + else if (h < 4.0f/6.0f) + return m1 + (m2 - m1) * (2.0f/3.0f - h) * 6.0f; + return m1; +} + +struct NVGcolor nvgHSLA(float h, float s, float l, unsigned char a) +{ + float m1, m2; + struct NVGcolor col; + h = nvg__modf(h, 1.0f); + if (h < 0.0f) h += 1.0f; + s = nvg__clampf(s, 0.0f, 1.0f); + l = nvg__clampf(l, 0.0f, 1.0f); + m2 = l <= 0.5f ? (l * (1 + s)) : (l + s - l * s); + m1 = 2 * l - m2; + col.r = nvg__clampf(nvg__hue(h + 1.0f/3.0f, m1, m2), 0.0f, 1.0f); + col.g = nvg__clampf(nvg__hue(h, m1, m2), 0.0f, 1.0f); + col.b = nvg__clampf(nvg__hue(h - 1.0f/3.0f, m1, m2), 0.0f, 1.0f); + col.a = a/255.0f; + return col; +} + + +static struct NVGstate* nvg__getState(struct NVGcontext* ctx) +{ + return &ctx->states[ctx->nstates-1]; +} + +void nvgTransformIdentity(float* t) +{ + t[0] = 1.0f; t[1] = 0.0f; + t[2] = 0.0f; t[3] = 1.0f; + t[4] = 0.0f; t[5] = 0.0f; +} + +void nvgTransformTranslate(float* t, float tx, float ty) +{ + t[0] = 1.0f; t[1] = 0.0f; + t[2] = 0.0f; t[3] = 1.0f; + t[4] = tx; t[5] = ty; +} + +void nvgTransformScale(float* t, float sx, float sy) +{ + t[0] = sx; t[1] = 0.0f; + t[2] = 0.0f; t[3] = sy; + t[4] = 0.0f; t[5] = 0.0f; +} + +void nvgTransformRotate(float* t, float a) +{ + float cs = nvg__cosf(a), sn = nvg__sinf(a); + t[0] = cs; t[1] = sn; + t[2] = -sn; t[3] = cs; + t[4] = 0.0f; t[5] = 0.0f; +} + +void nvgTransformSkewX(float* t, float a) +{ + t[0] = 1.0f; t[1] = 0.0f; + t[2] = nvg__tanf(a); t[3] = 1.0f; + t[4] = 0.0f; t[5] = 0.0f; +} + +void nvgTransformSkewY(float* t, float a) +{ + t[0] = 1.0f; t[1] = nvg__tanf(a); + t[2] = 0.0f; t[3] = 1.0f; + t[4] = 0.0f; t[5] = 0.0f; +} + +void nvgTransformMultiply(float* t, const float* s) +{ + float t0 = t[0] * s[0] + t[1] * s[2]; + float t2 = t[2] * s[0] + t[3] * s[2]; + float t4 = t[4] * s[0] + t[5] * s[2] + s[4]; + t[1] = t[0] * s[1] + t[1] * s[3]; + t[3] = t[2] * s[1] + t[3] * s[3]; + t[5] = t[4] * s[1] + t[5] * s[3] + s[5]; + t[0] = t0; + t[2] = t2; + t[4] = t4; +} + +void nvgTransformPremultiply(float* t, const float* s) +{ + float s2[6]; + memcpy(s2, s, sizeof(float)*6); + nvgTransformMultiply(s2, t); + memcpy(t, s2, sizeof(float)*6); +} + +int nvgTransformInverse(float* inv, const float* t) +{ + double invdet, det = (double)t[0] * t[3] - (double)t[2] * t[1]; + if (det > -1e-6 && det < 1e-6) { + nvgTransformIdentity(inv); + return 0; + } + invdet = 1.0 / det; + inv[0] = (float)(t[3] * invdet); + inv[2] = (float)(-t[2] * invdet); + inv[4] = (float)(((double)t[2] * t[5] - (double)t[3] * t[4]) * invdet); + inv[1] = (float)(-t[1] * invdet); + inv[3] = (float)(t[0] * invdet); + inv[5] = (float)(((double)t[1] * t[4] - (double)t[0] * t[5]) * invdet); + return 1; +} + +void nvgTransformPoint(float* dx, float* dy, const float* t, float sx, float sy) +{ + *dx = sx*t[0] + sy*t[2] + t[4]; + *dy = sx*t[1] + sy*t[3] + t[5]; +} + +float nvgDegToRad(float deg) +{ + return deg / 180.0f * NVG_PI; +} + +float nvgRadToDeg(float rad) +{ + return rad / NVG_PI * 180.0f; +} + +static void nvg__setPaintColor(struct NVGpaint* p, struct NVGcolor color) +{ + memset(p, 0, sizeof(*p)); + nvgTransformIdentity(p->xform); + p->radius = 0.0f; + p->feather = 1.0f; + p->innerColor = color; + p->outerColor = color; +} + + +// State handling +void nvgSave(struct NVGcontext* ctx) +{ + if (ctx->nstates >= NVG_MAX_STATES) + return; + if (ctx->nstates > 0) + memcpy(&ctx->states[ctx->nstates], &ctx->states[ctx->nstates-1], sizeof(struct NVGstate)); + ctx->nstates++; +} + +void nvgRestore(struct NVGcontext* ctx) +{ + if (ctx->nstates <= 1) + return; + ctx->nstates--; +} + +void nvgReset(struct NVGcontext* ctx) +{ + struct NVGstate* state = nvg__getState(ctx); + memset(state, 0, sizeof(*state)); + + nvg__setPaintColor(&state->fill, nvgRGBA(255,255,255,255)); + nvg__setPaintColor(&state->stroke, nvgRGBA(0,0,0,255)); + state->strokeWidth = 1.0f; + state->miterLimit = 10.0f; + state->lineCap = NVG_BUTT; + state->lineJoin = NVG_MITER; + nvgTransformIdentity(state->xform); + + state->scissor.extent[0] = 0.0f; + state->scissor.extent[1] = 0.0f; + + state->fontSize = 16.0f; + state->letterSpacing = 0.0f; + state->lineHeight = 0.0f; + state->fontBlur = 0.0f; + state->textAlign = NVG_ALIGN_LEFT | NVG_ALIGN_BASELINE; + state->fontId = 0; +} + +// State setting +void nvgStrokeWidth(struct NVGcontext* ctx, float width) +{ + struct NVGstate* state = nvg__getState(ctx); + state->strokeWidth = width; +} + +void nvgMiterLimit(struct NVGcontext* ctx, float limit) +{ + struct NVGstate* state = nvg__getState(ctx); + state->miterLimit = limit; +} + +void nvgLineCap(struct NVGcontext* ctx, int cap) +{ + struct NVGstate* state = nvg__getState(ctx); + state->lineCap = cap; +} + +void nvgLineJoin(struct NVGcontext* ctx, int join) +{ + struct NVGstate* state = nvg__getState(ctx); + state->lineJoin = join; +} + + +void nvgTransform(struct NVGcontext* ctx, float a, float b, float c, float d, float e, float f) +{ + struct NVGstate* state = nvg__getState(ctx); + float t[6] = { a, b, c, d, e, f }; + nvgTransformPremultiply(state->xform, t); +} + +void nvgResetTransform(struct NVGcontext* ctx) +{ + struct NVGstate* state = nvg__getState(ctx); + nvgTransformIdentity(state->xform); +} + +void nvgTranslate(struct NVGcontext* ctx, float x, float y) +{ + struct NVGstate* state = nvg__getState(ctx); + float t[6]; + nvgTransformTranslate(t, x,y); + nvgTransformPremultiply(state->xform, t); +} + +void nvgRotate(struct NVGcontext* ctx, float angle) +{ + struct NVGstate* state = nvg__getState(ctx); + float t[6]; + nvgTransformRotate(t, angle); + nvgTransformPremultiply(state->xform, t); +} + +void nvgSkewX(struct NVGcontext* ctx, float angle) +{ + struct NVGstate* state = nvg__getState(ctx); + float t[6]; + nvgTransformSkewX(t, angle); + nvgTransformPremultiply(state->xform, t); +} + +void nvgSkewY(struct NVGcontext* ctx, float angle) +{ + struct NVGstate* state = nvg__getState(ctx); + float t[6]; + nvgTransformSkewY(t, angle); + nvgTransformPremultiply(state->xform, t); +} + +void nvgScale(struct NVGcontext* ctx, float x, float y) +{ + struct NVGstate* state = nvg__getState(ctx); + float t[6]; + nvgTransformScale(t, x,y); + nvgTransformPremultiply(state->xform, t); +} + +void nvgCurrentTransform(struct NVGcontext* ctx, float* xform) +{ + struct NVGstate* state = nvg__getState(ctx); + if (xform == NULL) return; + memcpy(xform, state->xform, sizeof(float)*6); +} + +void nvgStrokeColor(struct NVGcontext* ctx, struct NVGcolor color) +{ + struct NVGstate* state = nvg__getState(ctx); + nvg__setPaintColor(&state->stroke, color); +} + +void nvgStrokePaint(struct NVGcontext* ctx, struct NVGpaint paint) +{ + struct NVGstate* state = nvg__getState(ctx); + state->stroke = paint; + nvgTransformMultiply(state->stroke.xform, state->xform); +} + +void nvgFillColor(struct NVGcontext* ctx, struct NVGcolor color) +{ + struct NVGstate* state = nvg__getState(ctx); + nvg__setPaintColor(&state->fill, color); +} + +void nvgFillPaint(struct NVGcontext* ctx, struct NVGpaint paint) +{ + struct NVGstate* state = nvg__getState(ctx); + state->fill = paint; + nvgTransformMultiply(state->fill.xform, state->xform); +} + +int nvgCreateImage(struct NVGcontext* ctx, const char* filename) +{ + int w, h, n, image; + unsigned char* img = stbi_load(filename, &w, &h, &n, 4); + if (img == NULL) { +// printf("Failed to load %s - %s\n", filename, stbi_failure_reason()); + return 0; + } + image = nvgCreateImageRGBA(ctx, w, h, img); + stbi_image_free(img); + return image; +} + +int nvgCreateImageMem(struct NVGcontext* ctx, unsigned char* data, int ndata) +{ + int w, h, n, image; + unsigned char* img = stbi_load_from_memory(data, ndata, &w, &h, &n, 4); + if (img == NULL) { +// printf("Failed to load %s - %s\n", filename, stbi_failure_reason()); + return 0; + } + image = nvgCreateImageRGBA(ctx, w, h, img); + stbi_image_free(img); + return image; +} + +int nvgCreateImageRGBA(struct NVGcontext* ctx, int w, int h, const unsigned char* data) +{ + return ctx->params.renderCreateTexture(ctx->params.userPtr, NVG_TEXTURE_RGBA, w, h, data); +} + +void nvgUpdateImage(struct NVGcontext* ctx, int image, const unsigned char* data) +{ + int w, h; + ctx->params.renderGetTextureSize(ctx->params.userPtr, image, &w, &h); + ctx->params.renderUpdateTexture(ctx->params.userPtr, image, 0,0, w,h, data); +} + +void nvgImageSize(struct NVGcontext* ctx, int image, int* w, int* h) +{ + ctx->params.renderGetTextureSize(ctx->params.userPtr, image, w, h); +} + +void nvgDeleteImage(struct NVGcontext* ctx, int image) +{ + ctx->params.renderDeleteTexture(ctx->params.userPtr, image); +} + +struct NVGpaint nvgLinearGradient(struct NVGcontext* ctx, + float sx, float sy, float ex, float ey, + struct NVGcolor icol, struct NVGcolor ocol) +{ + struct NVGpaint p; + float dx, dy, d; + const float large = 1e5; + NVG_NOTUSED(ctx); + memset(&p, 0, sizeof(p)); + + // Calculate transform aligned to the line + dx = ex - sx; + dy = ey - sy; + d = sqrtf(dx*dx + dy*dy); + if (d > 0.0001f) { + dx /= d; + dy /= d; + } else { + dx = 0; + dy = 1; + } + + p.xform[0] = dy; p.xform[1] = -dx; + p.xform[2] = dx; p.xform[3] = dy; + p.xform[4] = sx - dx*large; p.xform[5] = sy - dy*large; + + p.extent[0] = large; + p.extent[1] = large + d*0.5f; + + p.radius = 0.0f; + + p.feather = nvg__maxf(1.0f, d); + + p.innerColor = icol; + p.outerColor = ocol; + + return p; +} + +struct NVGpaint nvgRadialGradient(struct NVGcontext* ctx, + float cx, float cy, float inr, float outr, + struct NVGcolor icol, struct NVGcolor ocol) +{ + struct NVGpaint p; + float r = (inr+outr)*0.5f; + float f = (outr-inr); + NVG_NOTUSED(ctx); + memset(&p, 0, sizeof(p)); + + nvgTransformIdentity(p.xform); + p.xform[4] = cx; + p.xform[5] = cy; + + p.extent[0] = r; + p.extent[1] = r; + + p.radius = r; + + p.feather = nvg__maxf(1.0f, f); + + p.innerColor = icol; + p.outerColor = ocol; + + return p; +} + +struct NVGpaint nvgBoxGradient(struct NVGcontext* ctx, + float x, float y, float w, float h, float r, float f, + struct NVGcolor icol, struct NVGcolor ocol) +{ + struct NVGpaint p; + NVG_NOTUSED(ctx); + memset(&p, 0, sizeof(p)); + + nvgTransformIdentity(p.xform); + p.xform[4] = x+w*0.5f; + p.xform[5] = y+h*0.5f; + + p.extent[0] = w*0.5f; + p.extent[1] = h*0.5f; + + p.radius = r; + + p.feather = nvg__maxf(1.0f, f); + + p.innerColor = icol; + p.outerColor = ocol; + + return p; +} + + +struct NVGpaint nvgImagePattern(struct NVGcontext* ctx, + float cx, float cy, float w, float h, float angle, + int image, int repeat) +{ + struct NVGpaint p; + NVG_NOTUSED(ctx); + memset(&p, 0, sizeof(p)); + + nvgTransformRotate(p.xform, angle); + p.xform[4] = cx; + p.xform[5] = cy; + + p.extent[0] = w; + p.extent[1] = h; + + p.image = image; + p.repeat = repeat; + + return p; +} + +// Scissoring +void nvgScissor(struct NVGcontext* ctx, float x, float y, float w, float h) +{ + struct NVGstate* state = nvg__getState(ctx); + + nvgTransformIdentity(state->scissor.xform); + state->scissor.xform[4] = x+w*0.5f; + state->scissor.xform[5] = y+h*0.5f; + nvgTransformMultiply(state->scissor.xform, state->xform); + + state->scissor.extent[0] = w*0.5f; + state->scissor.extent[1] = h*0.5f; +} + +void nvgResetScissor(struct NVGcontext* ctx) +{ + struct NVGstate* state = nvg__getState(ctx); + memset(state->scissor.xform, 0, sizeof(state->scissor.xform)); + state->scissor.extent[0] = 0; + state->scissor.extent[1] = 0; +} + +static int nvg__ptEquals(float x1, float y1, float x2, float y2, float tol) +{ + float dx = x2 - x1; + float dy = y2 - y1; + return dx*dx + dy*dy < tol*tol; +} + +static float nvg__distPtSeg(float x, float y, float px, float py, float qx, float qy) +{ + float pqx, pqy, dx, dy, d, t; + pqx = qx-px; + pqy = qy-py; + dx = x-px; + dy = y-py; + d = pqx*pqx + pqy*pqy; + t = pqx*dx + pqy*dy; + if (d > 0) t /= d; + if (t < 0) t = 0; + else if (t > 1) t = 1; + dx = px + t*pqx - x; + dy = py + t*pqy - y; + return dx*dx + dy*dy; +} + +static void nvg__appendCommands(struct NVGcontext* ctx, float* vals, int nvals) +{ + struct NVGstate* state = nvg__getState(ctx); + int i; + + if (ctx->ncommands+nvals > ctx->ccommands) { + float* commands; + int ccommands = ctx->ncommands+nvals + ctx->ccommands/2; + commands = (float*)realloc(ctx->commands, sizeof(float)*ccommands); + if (commands == NULL) return; + ctx->commands = commands; + ctx->ccommands = ccommands; + } + + // transform commands + i = 0; + while (i < nvals) { + int cmd = (int)vals[i]; + switch (cmd) { + case NVG_MOVETO: + nvgTransformPoint(&vals[i+1],&vals[i+2], state->xform, vals[i+1],vals[i+2]); + i += 3; + break; + case NVG_LINETO: + nvgTransformPoint(&vals[i+1],&vals[i+2], state->xform, vals[i+1],vals[i+2]); + i += 3; + break; + case NVG_BEZIERTO: + nvgTransformPoint(&vals[i+1],&vals[i+2], state->xform, vals[i+1],vals[i+2]); + nvgTransformPoint(&vals[i+3],&vals[i+4], state->xform, vals[i+3],vals[i+4]); + nvgTransformPoint(&vals[i+5],&vals[i+6], state->xform, vals[i+5],vals[i+6]); + i += 7; + break; + case NVG_CLOSE: + i++; + break; + case NVG_WINDING: + i += 2; + break; + default: + i++; + } + } + + memcpy(&ctx->commands[ctx->ncommands], vals, nvals*sizeof(float)); + + ctx->ncommands += nvals; + + if ((int)vals[0] != NVG_CLOSE && (int)vals[0] != NVG_WINDING) { + ctx->commandx = vals[nvals-2]; + ctx->commandy = vals[nvals-1]; + } +} + + +static void nvg__clearPathCache(struct NVGcontext* ctx) +{ + ctx->cache->npoints = 0; + ctx->cache->npaths = 0; +} + +static struct NVGpath* nvg__lastPath(struct NVGcontext* ctx) +{ + if (ctx->cache->npaths > 0) + return &ctx->cache->paths[ctx->cache->npaths-1]; + return NULL; +} + +static void nvg__addPath(struct NVGcontext* ctx) +{ + struct NVGpath* path; + if (ctx->cache->npaths+1 > ctx->cache->cpaths) { + struct NVGpath* paths; + int cpaths = ctx->cache->npaths+1 + ctx->cache->cpaths/2; + paths = (struct NVGpath*)realloc(ctx->cache->paths, sizeof(struct NVGpath)*cpaths); + if (paths == NULL) return; + ctx->cache->paths = paths; + ctx->cache->cpaths = cpaths; + } + path = &ctx->cache->paths[ctx->cache->npaths]; + memset(path, 0, sizeof(*path)); + path->first = ctx->cache->npoints; + path->winding = NVG_CCW; + + ctx->cache->npaths++; +} + +static struct NVGpoint* nvg__lastPoint(struct NVGcontext* ctx) +{ + if (ctx->cache->npoints > 0) + return &ctx->cache->points[ctx->cache->npoints-1]; + return NULL; +} + +static void nvg__addPoint(struct NVGcontext* ctx, float x, float y, int flags) +{ + struct NVGpath* path = nvg__lastPath(ctx); + struct NVGpoint* pt; + if (path == NULL) return; + + if (ctx->cache->npoints > 0) { + pt = nvg__lastPoint(ctx); + if (nvg__ptEquals(pt->x,pt->y, x,y, ctx->distTol)) { + pt->flags |= flags; + return; + } + } + + if (ctx->cache->npoints+1 > ctx->cache->cpoints) { + struct NVGpoint* points; + int cpoints = ctx->cache->npoints+1 + ctx->cache->cpoints/2; + points = (struct NVGpoint*)realloc(ctx->cache->points, sizeof(struct NVGpoint)*cpoints); + if (points == NULL) return; + ctx->cache->points = points; + ctx->cache->cpoints = cpoints; + } + + pt = &ctx->cache->points[ctx->cache->npoints]; + memset(pt, 0, sizeof(*pt)); + pt->x = x; + pt->y = y; + pt->flags = flags; + + ctx->cache->npoints++; + path->count++; +} + +static void nvg__closePath(struct NVGcontext* ctx) +{ + struct NVGpath* path = nvg__lastPath(ctx); + if (path == NULL) return; + path->closed = 1; +} + +static void nvg__pathWinding(struct NVGcontext* ctx, int winding) +{ + struct NVGpath* path = nvg__lastPath(ctx); + if (path == NULL) return; + path->winding = winding; +} + +static float nvg__getAverageScale(float *t) +{ + float sx = sqrtf(t[0]*t[0] + t[2]*t[2]); + float sy = sqrtf(t[1]*t[1] + t[3]*t[3]); + return (sx + sy) * 0.5f; +} + +static struct NVGvertex* nvg__allocTempVerts(struct NVGcontext* ctx, int nverts) +{ + if (nverts > ctx->cache->cverts) { + struct NVGvertex* verts; + int cverts = (nverts + 0xff) & ~0xff; // Round up to prevent allocations when things change just slightly. + verts = (struct NVGvertex*)realloc(ctx->cache->verts, sizeof(struct NVGvertex)*cverts); + if (verts == NULL) return NULL; + ctx->cache->verts = verts; + ctx->cache->cverts = cverts; + } + + return ctx->cache->verts; +} + +static float nvg__triarea2(float ax, float ay, float bx, float by, float cx, float cy) +{ + float abx = bx - ax; + float aby = by - ay; + float acx = cx - ax; + float acy = cy - ay; + return acx*aby - abx*acy; +} + +static float nvg__polyArea(struct NVGpoint* pts, int npts) +{ + int i; + float area = 0; + for (i = 2; i < npts; i++) { + struct NVGpoint* a = &pts[0]; + struct NVGpoint* b = &pts[i-1]; + struct NVGpoint* c = &pts[i]; + area += nvg__triarea2(a->x,a->y, b->x,b->y, c->x,c->y); + } + return area * 0.5f; +} + +static void nvg__polyReverse(struct NVGpoint* pts, int npts) +{ + struct NVGpoint tmp; + int i = 0, j = npts-1; + while (i < j) { + tmp = pts[i]; + pts[i] = pts[j]; + pts[j] = tmp; + i++; + j--; + } +} + + +static void nvg__vset(struct NVGvertex* vtx, float x, float y, float u, float v) +{ + vtx->x = x; + vtx->y = y; + vtx->u = u; + vtx->v = v; +} + +static void nvg__tesselateBezier(struct NVGcontext* ctx, + float x1, float y1, float x2, float y2, + float x3, float y3, float x4, float y4, + int level, int type) +{ + float x12,y12,x23,y23,x34,y34,x123,y123,x234,y234,x1234,y1234; + float dx,dy,d2,d3; + + if (level > 10) return; + + x12 = (x1+x2)*0.5f; + y12 = (y1+y2)*0.5f; + x23 = (x2+x3)*0.5f; + y23 = (y2+y3)*0.5f; + x34 = (x3+x4)*0.5f; + y34 = (y3+y4)*0.5f; + x123 = (x12+x23)*0.5f; + y123 = (y12+y23)*0.5f; + + dx = x3 - x1; + dy = y3 - y1; + d2 = nvg__absf(((x2 - x4) * dy - (y2 - y4) * dx)); + d3 = nvg__absf(((x3 - x4) * dy - (y3 - y4) * dx)); + + if ((d2 + d3)*(d2 + d3) < ctx->tessTol * (dx*dx + dy*dy)) { + nvg__addPoint(ctx, x4, y4, type); + return; + } + +/* if (nvg__absf(x1+x3-x2-x2) + nvg__absf(y1+y3-y2-y2) + nvg__absf(x2+x4-x3-x3) + nvg__absf(y2+y4-y3-y3) < ctx->tessTol) { + nvg__addPoint(ctx, x4, y4, type); + return; + }*/ + + x234 = (x23+x34)*0.5f; + y234 = (y23+y34)*0.5f; + x1234 = (x123+x234)*0.5f; + y1234 = (y123+y234)*0.5f; + + nvg__tesselateBezier(ctx, x1,y1, x12,y12, x123,y123, x1234,y1234, level+1, 0); + nvg__tesselateBezier(ctx, x1234,y1234, x234,y234, x34,y34, x4,y4, level+1, type); +} + +static void nvg__flattenPaths(struct NVGcontext* ctx) +{ + struct NVGpathCache* cache = ctx->cache; +// struct NVGstate* state = nvg__getState(ctx); + struct NVGpoint* last; + struct NVGpoint* p0; + struct NVGpoint* p1; + struct NVGpoint* pts; + struct NVGpath* path; + int i, j; + float* cp1; + float* cp2; + float* p; + float area; + + if (cache->npaths > 0) + return; + + // Flatten + i = 0; + while (i < ctx->ncommands) { + int cmd = (int)ctx->commands[i]; + switch (cmd) { + case NVG_MOVETO: + nvg__addPath(ctx); + p = &ctx->commands[i+1]; + nvg__addPoint(ctx, p[0], p[1], NVG_PT_CORNER); + i += 3; + break; + case NVG_LINETO: + p = &ctx->commands[i+1]; + nvg__addPoint(ctx, p[0], p[1], NVG_PT_CORNER); + i += 3; + break; + case NVG_BEZIERTO: + last = nvg__lastPoint(ctx); + if (last != NULL) { + cp1 = &ctx->commands[i+1]; + cp2 = &ctx->commands[i+3]; + p = &ctx->commands[i+5]; + nvg__tesselateBezier(ctx, last->x,last->y, cp1[0],cp1[1], cp2[0],cp2[1], p[0],p[1], 0, NVG_PT_CORNER); + } + i += 7; + break; + case NVG_CLOSE: + nvg__closePath(ctx); + i++; + break; + case NVG_WINDING: + nvg__pathWinding(ctx, (int)ctx->commands[i+1]); + i += 2; + break; + default: + i++; + } + } + + cache->bounds[0] = cache->bounds[1] = 1e6f; + cache->bounds[2] = cache->bounds[3] = -1e6f; + + // Calculate the direction and length of line segments. + for (j = 0; j < cache->npaths; j++) { + path = &cache->paths[j]; + pts = &cache->points[path->first]; + + // If the first and last points are the same, remove the last, mark as closed path. + p0 = &pts[path->count-1]; + p1 = &pts[0]; + if (nvg__ptEquals(p0->x,p0->y, p1->x,p1->y, ctx->distTol)) { + path->count--; + p0 = &pts[path->count-1]; + path->closed = 1; + } + + // Enforce winding. + if (path->count > 2) { + area = nvg__polyArea(pts, path->count); + if (path->winding == NVG_CCW && area < 0.0f) + nvg__polyReverse(pts, path->count); + if (path->winding == NVG_CW && area > 0.0f) + nvg__polyReverse(pts, path->count); + } + + for(i = 0; i < path->count; ++i) { + // Calculate segment direction and length + p0->dx = p1->x - p0->x; + p0->dy = p1->y - p0->y; + p0->len = nvg__normalize(&p0->dx, &p0->dy); + // Update bounds + cache->bounds[0] = nvg__minf(cache->bounds[0], p0->x); + cache->bounds[1] = nvg__minf(cache->bounds[1], p0->y); + cache->bounds[2] = nvg__maxf(cache->bounds[2], p0->x); + cache->bounds[3] = nvg__maxf(cache->bounds[3], p0->y); + // Advance + p0 = p1++; + } + } +} + +static int nvg__curveDivs(float r, float arc, float tol) +{ + float da = acosf(r / (r + tol)) * 2.0f; + return nvg__maxi(2, (int)ceilf(arc / da)); +} + +static void nvg__chooseBevel(int bevel, struct NVGpoint* p0, struct NVGpoint* p1, float w, + float* x0, float* y0, float* x1, float* y1) +{ + if (bevel) { + *x0 = p1->x + p0->dy * w; + *y0 = p1->y - p0->dx * w; + *x1 = p1->x + p1->dy * w; + *y1 = p1->y - p1->dx * w; + } else { + *x0 = p1->x + p1->dmx * w; + *y0 = p1->y + p1->dmy * w; + *x1 = p1->x + p1->dmx * w; + *y1 = p1->y + p1->dmy * w; + } +} + +static struct NVGvertex* nvg__roundJoin(struct NVGvertex* dst, struct NVGpoint* p0, struct NVGpoint* p1, + float lw, float rw, float lu, float ru, int ncap, float fringe) +{ + int i, n; + float dlx0 = p0->dy; + float dly0 = -p0->dx; + float dlx1 = p1->dy; + float dly1 = -p1->dx; + NVG_NOTUSED(fringe); + + if (p1->flags & NVG_PT_LEFT) { + float lx0,ly0,lx1,ly1,a0,a1; + nvg__chooseBevel(p1->flags & NVG_PR_INNERBEVEL, p0, p1, lw, &lx0,&ly0, &lx1,&ly1); + a0 = atan2f(-dly0, -dlx0); + a1 = atan2f(-dly1, -dlx1); + if (a1 > a0) a1 -= NVG_PI*2; + + nvg__vset(dst, lx0, ly0, lu,1); dst++; + nvg__vset(dst, p1->x - dlx0*rw, p1->y - dly0*rw, ru,1); dst++; + + n = nvg__clampi((int)ceilf(((a0 - a1) / NVG_PI) * ncap), 2, ncap); + for (i = 0; i < n; i++) { + float u = i/(float)(n-1); + float a = a0 + u*(a1-a0); + float rx = p1->x + cosf(a) * rw; + float ry = p1->y + sinf(a) * rw; + nvg__vset(dst, p1->x, p1->y, 0.5f,1); dst++; + nvg__vset(dst, rx, ry, ru,1); dst++; + } + + nvg__vset(dst, lx1, ly1, lu,1); dst++; + nvg__vset(dst, p1->x - dlx1*rw, p1->y - dly1*rw, ru,1); dst++; + + } else { + float rx0,ry0,rx1,ry1,a0,a1; + nvg__chooseBevel(p1->flags & NVG_PR_INNERBEVEL, p0, p1, -rw, &rx0,&ry0, &rx1,&ry1); + a0 = atan2f(dly0, dlx0); + a1 = atan2f(dly1, dlx1); + if (a1 < a0) a1 += NVG_PI*2; + + nvg__vset(dst, p1->x + dlx0*rw, p1->y + dly0*rw, lu,1); dst++; + nvg__vset(dst, rx0, ry0, ru,1); dst++; + + n = nvg__clampi((int)ceilf(((a1 - a0) / NVG_PI) * ncap), 2, ncap); + for (i = 0; i < n; i++) { + float u = i/(float)(n-1); + float a = a0 + u*(a1-a0); + float lx = p1->x + cosf(a) * lw; + float ly = p1->y + sinf(a) * lw; + nvg__vset(dst, lx, ly, lu,1); dst++; + nvg__vset(dst, p1->x, p1->y, 0.5f,1); dst++; + } + + nvg__vset(dst, p1->x + dlx1*rw, p1->y + dly1*rw, lu,1); dst++; + nvg__vset(dst, rx1, ry1, ru,1); dst++; + + } + return dst; +} + +static struct NVGvertex* nvg__bevelJoin(struct NVGvertex* dst, struct NVGpoint* p0, struct NVGpoint* p1, + float lw, float rw, float lu, float ru, float fringe) +{ + float rx0,ry0,rx1,ry1; + float lx0,ly0,lx1,ly1; + float mx,my,len,mu; + float dlx0 = p0->dy; + float dly0 = -p0->dx; + float dlx1 = p1->dy; + float dly1 = -p1->dx; + NVG_NOTUSED(fringe); + + if (p1->flags & NVG_PT_LEFT) { + nvg__chooseBevel(p1->flags & NVG_PR_INNERBEVEL, p0, p1, lw, &lx0,&ly0, &lx1,&ly1); + + nvg__vset(dst, lx0, ly0, lu,1); dst++; + nvg__vset(dst, p1->x - dlx0*rw, p1->y - dly0*rw, ru,1); dst++; + + if (p1->flags & NVG_PT_BEVEL) { + // TODO: this needs more work. + mx = (dlx0 + dlx1) * 0.5f; + my = (dly0 + dly1) * 0.5f; + len = sqrtf(mx*mx + my*my); + mu = ru + len*(lu-ru)*0.5f; + + nvg__vset(dst, lx0, ly0, lu,1); dst++; + nvg__vset(dst, p1->x - dlx0*rw, p1->y - dly0*rw, ru,1); dst++; + + nvg__vset(dst, lx1, ly1, lu,1); dst++; + nvg__vset(dst, p1->x - dlx1*rw, p1->y - dly1*rw, ru,1); dst++; + } else { + rx0 = p1->x - p1->dmx * rw; + ry0 = p1->y - p1->dmy * rw; + + nvg__vset(dst, p1->x, p1->y, 0.5f,1); dst++; + nvg__vset(dst, p1->x - dlx0*rw, p1->y - dly0*rw, ru,1); dst++; + + nvg__vset(dst, rx0, ry0, ru,1); dst++; + nvg__vset(dst, rx0, ry0, ru,1); dst++; + + nvg__vset(dst, p1->x, p1->y, 0.5f,1); dst++; + nvg__vset(dst, p1->x - dlx1*rw, p1->y - dly1*rw, ru,1); dst++; + } + + nvg__vset(dst, lx1, ly1, lu,1); dst++; + nvg__vset(dst, p1->x - dlx1*rw, p1->y - dly1*rw, ru,1); dst++; + + } else { + nvg__chooseBevel(p1->flags & NVG_PR_INNERBEVEL, p0, p1, -rw, &rx0,&ry0, &rx1,&ry1); + + nvg__vset(dst, p1->x + dlx0*lw, p1->y + dly0*lw, lu,1); dst++; + nvg__vset(dst, rx0, ry0, ru,1); dst++; + + if (p1->flags & NVG_PT_BEVEL) { + // TODO: this needs more work. + mx = (dlx0 + dlx1) * 0.5f; + my = (dly0 + dly1) * 0.5f; + len = sqrtf(mx*mx + my*my); + mu = lu + len*(ru-lu)*0.5f; + + nvg__vset(dst, p1->x + dlx0*lw, p1->y + dly0*lw, lu,1); dst++; + nvg__vset(dst, rx0, ry0, ru,1); dst++; + + nvg__vset(dst, p1->x + dlx1*lw, p1->y + dly1*lw, lu,1); dst++; + nvg__vset(dst, rx1, ry1, ru,1); dst++; + } else { + lx0 = p1->x + p1->dmx * lw; + ly0 = p1->y + p1->dmy * lw; + + nvg__vset(dst, p1->x + dlx0*lw, p1->y + dly0*lw, lu,1); dst++; + nvg__vset(dst, p1->x, p1->y, 0.5f,1); dst++; + + nvg__vset(dst, lx0, ly0, lu,1); dst++; + nvg__vset(dst, lx0, ly0, lu,1); dst++; + + nvg__vset(dst, p1->x + dlx1*lw, p1->y + dly1*lw, lu,1); dst++; + nvg__vset(dst, p1->x, p1->y, 0.5f,1); dst++; + } + + nvg__vset(dst, p1->x + dlx1*lw, p1->y + dly1*lw, lu,1); dst++; + nvg__vset(dst, rx1, ry1, ru,1); dst++; + } + + return dst; + + NVG_NOTUSED(mu); +} + +static int nvg__expandStrokeAndFill(struct NVGcontext* ctx, int feats, float w, int lineCap, int lineJoin, float miterLimit) +{ + struct NVGpathCache* cache = ctx->cache; + struct NVGpath* path; + struct NVGpoint* pts; + struct NVGvertex* verts; + struct NVGvertex* dst; + struct NVGpoint* p0; + struct NVGpoint* p1; + int cverts, convex, i, j, s, e; + float wo = 0, iw = 0, aa = ctx->fringeWidth; + int ncap = nvg__curveDivs(w, NVG_PI, ctx->tessTol / 4.0f); + int nleft = 0; + + if (w > 0.0f) iw = 1.0f / w; + + // Calculate which joins needs extra vertices to append, and gather vertex count. + for (i = 0; i < cache->npaths; i++) { + path = &cache->paths[i]; + pts = &cache->points[path->first]; + path->nbevel = 0; + nleft = 0; + + p0 = &pts[path->count-1]; + p1 = &pts[0]; + for (j = 0; j < path->count; j++) { + float dlx0, dly0, dlx1, dly1, dmr2, cross, limit; + dlx0 = p0->dy; + dly0 = -p0->dx; + dlx1 = p1->dy; + dly1 = -p1->dx; + // Calculate extrusions + p1->dmx = (dlx0 + dlx1) * 0.5f; + p1->dmy = (dly0 + dly1) * 0.5f; + dmr2 = p1->dmx*p1->dmx + p1->dmy*p1->dmy; + if (dmr2 > 0.000001f) { + float scale = 1.0f / dmr2; + if (scale > 600.0f) { + scale = 600.0f; + } + p1->dmx *= scale; + p1->dmy *= scale; + } + + // Clear flags, but keep the corner. + p1->flags = (p1->flags & NVG_PT_CORNER) ? NVG_PT_CORNER : 0; + + // Keep track of left turns. + cross = p1->dx * p0->dy - p0->dx * p1->dy; + if (cross > 0.0f) { + nleft++; + p1->flags |= NVG_PT_LEFT; + } + + // Calculate if we should use bevel or miter for inner join. + limit = nvg__maxf(1.01f, nvg__minf(p0->len, p1->len) * iw); + if ((dmr2 * limit*limit) < 1.0f) + p1->flags |= NVG_PR_INNERBEVEL; + + // Check to see if the corner needs to be beveled. + if (p1->flags & NVG_PT_CORNER) { + if ((dmr2 * miterLimit*miterLimit) < 1.0f || lineJoin == NVG_BEVEL || lineJoin == NVG_ROUND) { + p1->flags |= NVG_PT_BEVEL; + } + } + + if ((p1->flags & (NVG_PT_BEVEL | NVG_PR_INNERBEVEL)) != 0) + path->nbevel++; + + p0 = p1++; + } + + path->convex = (nleft == path->count) ? 1 : 0; + } + + // Calculate max vertex usage. + cverts = 0; + for (i = 0; i < cache->npaths; i++) { + path = &cache->paths[i]; + if (feats & NVG_FILL) + cverts += path->count + path->nbevel + 1; + if (feats & NVG_STROKE) { + int loop = ((feats & NVG_CAPS) && path->closed == 0) ? 0 : 1; + if (lineCap == NVG_ROUND) + cverts += (path->count + path->nbevel*(ncap+2) + 1) * 2; // plus one for loop + else + cverts += (path->count + path->nbevel*5 + 1) * 2; // plus one for loop + if (loop == 0) { + // space for caps + if (lineCap == NVG_ROUND) { + cverts += (ncap*2 + 2)*2; + } else { + cverts += (3+3)*2; + } + } + } + } + + verts = nvg__allocTempVerts(ctx, cverts); + if (verts == NULL) return 0; + + if ((feats & NVG_FILL) && cache->npaths == 1 && cache->paths[0].convex) + convex = 1; + else + convex = 0; + + for (i = 0; i < cache->npaths; i++) { + path = &cache->paths[i]; + pts = &cache->points[path->first]; + + // Calculate shape vertices. + if (feats & NVG_FILL) { + wo = 0.5f*aa; + dst = verts; + path->fill = dst; + + if (w == 0.0f) { + for (j = 0; j < path->count; ++j) { + nvg__vset(dst, pts[j].x, pts[j].y, 0.5f,1); + dst++; + } + } else { + // Looping + p0 = &pts[path->count-1]; + p1 = &pts[0]; + for (j = 0; j < path->count; ++j) { + if (p1->flags & NVG_PT_BEVEL) { + float dlx0 = p0->dy; + float dly0 = -p0->dx; + float dlx1 = p1->dy; + float dly1 = -p1->dx; + if (p1->flags & NVG_PT_LEFT) { + float lx = p1->x + p1->dmx * wo; + float ly = p1->y + p1->dmy * wo; + nvg__vset(dst, lx, ly, 0.5f,1); dst++; + } else { + float lx0 = p1->x + dlx0 * wo; + float ly0 = p1->y + dly0 * wo; + float lx1 = p1->x + dlx1 * wo; + float ly1 = p1->y + dly1 * wo; + nvg__vset(dst, lx0, ly0, 0.5f,1); dst++; + nvg__vset(dst, lx1, ly1, 0.5f,1); dst++; + } + } else { + nvg__vset(dst, p1->x + (p1->dmx * wo), p1->y + (p1->dmy * wo), 0.5f,1); dst++; + } + p0 = p1++; + } + } + + path->nfill = (int)(dst - verts); + verts = dst; + } else { + wo = 0.0f; + path->fill = 0; + path->nfill = 0; + } + + // Calculate fringe or stroke + if (feats & NVG_STROKE) { + float lw = w + wo, rw = w - wo; + float lu = 0, ru = 1; + int loop = ((feats & NVG_CAPS) && path->closed == 0) ? 0 : 1; + dst = verts; + path->stroke = dst; + + // Create only half a fringe for convex shapes so that + // the shape can be rendered without stenciling. + if (convex) { + lw = wo; // This should generate the same vertex as fill inset above. + lu = 0.5f; // Set outline fade at middle. + } + + if (loop) { + // Looping + p0 = &pts[path->count-1]; + p1 = &pts[0]; + s = 0; + e = path->count; + } else { + // Add cap + p0 = &pts[0]; + p1 = &pts[1]; + s = 1; + e = path->count-1; + } + + if (loop == 0) { + // Add cap + float dx, dy, dlx, dly, px, py; + dx = p1->x - p0->x; + dy = p1->y - p0->y; + nvg__normalize(&dx, &dy); + dlx = dy; + dly = -dx; + if (lineCap == NVG_BUTT || lineCap == NVG_SQUARE) { + if (lineCap == NVG_BUTT) { + px = p0->x + dx*ctx->fringeWidth*0.5f; + py = p0->y + dy*ctx->fringeWidth*0.5f; + } else /*if (lineCap == NVG_SQUARE)*/ { + px = p0->x - dx*(w - ctx->fringeWidth); + py = p0->y - dy*(w - ctx->fringeWidth); + } + nvg__vset(dst, px + dlx*lw - dx*aa, py + dly*lw - dy*aa, lu,0); dst++; + nvg__vset(dst, px - dlx*rw - dx*aa, py - dly*rw - dy*aa, ru,0); dst++; + nvg__vset(dst, px + dlx*lw, py + dly * lw, lu,1); dst++; + nvg__vset(dst, px - dlx*rw, py - dly * rw, ru,1); dst++; + } else if (lineCap == NVG_ROUND) { + px = p0->x; + py = p0->y; + for (j = 0; j < ncap; j++) { + float a = j/(float)(ncap-1)*NVG_PI; + float ax = cosf(a) * w, ay = sinf(a) * w; + nvg__vset(dst, px - dlx*ax - dx*ay, py - dly*ax - dy*ay, lu,1); dst++; + nvg__vset(dst, px, py, 0.5f,1); dst++; + } + nvg__vset(dst, px + dlx*lw, py + dly * lw, lu,1); dst++; + nvg__vset(dst, px - dlx*rw, py - dly * rw, ru,1); dst++; + } + } + + for (j = s; j < e; ++j) { + if ((p1->flags & (NVG_PT_BEVEL | NVG_PR_INNERBEVEL)) != 0) { + if (lineJoin == NVG_ROUND) { + dst = nvg__roundJoin(dst, p0, p1, lw, rw, lu, ru, ncap, ctx->fringeWidth); + } else { + dst = nvg__bevelJoin(dst, p0, p1, lw, rw, lu, ru, ctx->fringeWidth); + } + } else { + nvg__vset(dst, p1->x + (p1->dmx * lw), p1->y + (p1->dmy * lw), lu,1); dst++; + nvg__vset(dst, p1->x - (p1->dmx * rw), p1->y - (p1->dmy * rw), ru,1); dst++; + } + p0 = p1++; + } + + if (loop) { + // Loop it + nvg__vset(dst, verts[0].x, verts[0].y, lu,1); dst++; + nvg__vset(dst, verts[1].x, verts[1].y, ru,1); dst++; + } else { + // Add cap + float dx, dy, dlx, dly, px, py; + dx = p1->x - p0->x; + dy = p1->y - p0->y; + nvg__normalize(&dx, &dy); + dlx = dy; + dly = -dx; + if (lineCap == NVG_BUTT || lineCap == NVG_SQUARE) { + if (lineCap == NVG_BUTT) { + px = p1->x - dx*ctx->fringeWidth*0.5f; + py = p1->y - dy*ctx->fringeWidth*0.5f; + } else /*if (lineCap == NVG_SQUARE)*/ { + px = p1->x + dx*(w - ctx->fringeWidth); + py = p1->y + dy*(w - ctx->fringeWidth); + } + nvg__vset(dst, px + dlx*lw, py + dly * lw, lu,1); dst++; + nvg__vset(dst, px - dlx*rw, py - dly * rw, ru,1); dst++; + nvg__vset(dst, px + dlx*lw + dx*aa, py + dly*lw + dy*aa, lu,0); dst++; + nvg__vset(dst, px - dlx*rw + dx*aa, py - dly*rw + dy*aa, ru,0); dst++; + } else if (lineCap == NVG_ROUND) { + px = p1->x; + py = p1->y; + nvg__vset(dst, px + dlx*lw, py + dly * lw, lu,1); dst++; + nvg__vset(dst, px - dlx*rw, py - dly * rw, ru,1); dst++; + for (j = 0; j < ncap; j++) { + float a = j/(float)(ncap-1)*NVG_PI; + float ax = cosf(a) * w, ay = sinf(a) * w; + nvg__vset(dst, px, py, 0.5f,1); dst++; + nvg__vset(dst, px - dlx*ax + dx*ay, py - dly*ax + dy*ay, lu,1); dst++; + } + } + } + + path->nstroke = (int)(dst - verts); + + verts = dst; + } else { + path->stroke = 0; + path->nstroke = 0; + } + } + + return 1; +} + + +// Draw +void nvgBeginPath(struct NVGcontext* ctx) +{ + ctx->ncommands = 0; + nvg__clearPathCache(ctx); +} + +void nvgMoveTo(struct NVGcontext* ctx, float x, float y) +{ + float vals[] = { NVG_MOVETO, x, y }; + nvg__appendCommands(ctx, vals, NVG_COUNTOF(vals)); +} + +void nvgLineTo(struct NVGcontext* ctx, float x, float y) +{ + float vals[] = { NVG_LINETO, x, y }; + nvg__appendCommands(ctx, vals, NVG_COUNTOF(vals)); +} + +void nvgBezierTo(struct NVGcontext* ctx, float c1x, float c1y, float c2x, float c2y, float x, float y) +{ + float vals[] = { NVG_BEZIERTO, c1x, c1y, c2x, c2y, x, y }; + nvg__appendCommands(ctx, vals, NVG_COUNTOF(vals)); +} + +void nvgArcTo(struct NVGcontext* ctx, float x1, float y1, float x2, float y2, float radius) +{ + float x0 = ctx->commandx; + float y0 = ctx->commandy; + float dx0,dy0, dx1,dy1, a, d, cx,cy, a0,a1; + int dir; + + if (ctx->ncommands == 0) { + return; + } + + // Handle degenerate cases. + if (nvg__ptEquals(x0,y0, x1,y1, ctx->distTol) || + nvg__ptEquals(x1,y1, x2,y2, ctx->distTol) || + nvg__distPtSeg(x1,y1, x0,y0, x2,y2) < ctx->distTol*ctx->distTol || + radius < ctx->distTol) { + nvgLineTo(ctx, x1,y1); + return; + } + + // Calculate tangential circle to lines (x0,y0)-(x1,y1) and (x1,y1)-(x2,y2). + dx0 = x0-x1; + dy0 = y0-y1; + dx1 = x2-x1; + dy1 = y2-y1; + nvg__normalize(&dx0,&dy0); + nvg__normalize(&dx1,&dy1); + a = nvg__acosf(dx0*dx1 + dy0*dy1); + d = radius / nvg__tanf(a/2.0f); + +// printf("a=%f° d=%f\n", a/NVG_PI*180.0f, d); + + if (d > 10000.0f) { + nvgLineTo(ctx, x1,y1); + return; + } + + if (nvg__cross(dx0,dy0, dx1,dy1) > 0.0f) { + cx = x1 + dx0*d + dy0*radius; + cy = y1 + dy0*d + -dx0*radius; + a0 = nvg__atan2f(dx0, -dy0); + a1 = nvg__atan2f(-dx1, dy1); + dir = NVG_CW; +// printf("CW c=(%f, %f) a0=%f° a1=%f°\n", cx, cy, a0/NVG_PI*180.0f, a1/NVG_PI*180.0f); + } else { + cx = x1 + dx0*d + -dy0*radius; + cy = y1 + dy0*d + dx0*radius; + a0 = nvg__atan2f(-dx0, dy0); + a1 = nvg__atan2f(dx1, -dy1); + dir = NVG_CCW; +// printf("CCW c=(%f, %f) a0=%f° a1=%f°\n", cx, cy, a0/NVG_PI*180.0f, a1/NVG_PI*180.0f); + } + + nvgArc(ctx, cx, cy, radius, a0, a1, dir); +} + +void nvgClosePath(struct NVGcontext* ctx) +{ + float vals[] = { NVG_CLOSE }; + nvg__appendCommands(ctx, vals, NVG_COUNTOF(vals)); +} + +void nvgPathWinding(struct NVGcontext* ctx, int dir) +{ + float vals[] = { NVG_WINDING, (float)dir }; + nvg__appendCommands(ctx, vals, NVG_COUNTOF(vals)); +} + +void nvgArc(struct NVGcontext* ctx, float cx, float cy, float r, float a0, float a1, int dir) +{ + float a = 0, da = 0, hda = 0, kappa = 0; + float dx = 0, dy = 0, x = 0, y = 0, tanx = 0, tany = 0; + float px = 0, py = 0, ptanx = 0, ptany = 0; + float vals[3 + 5*7 + 100]; + int i, ndivs, nvals; + int move = ctx->ncommands > 0 ? NVG_LINETO : NVG_MOVETO; + + // Clamp angles + da = a1 - a0; + if (dir == NVG_CW) { + if (nvg__absf(da) >= NVG_PI*2) { + da = NVG_PI*2; + } else { + while (da < 0.0f) da += NVG_PI*2; + } + } else { + if (nvg__absf(da) >= NVG_PI*2) { + da = -NVG_PI*2; + } else { + while (da > 0.0f) da -= NVG_PI*2; + } + } + + // Split arc into max 90 degree segments. + ndivs = nvg__maxi(1, nvg__mini((int)(nvg__absf(da) / (NVG_PI*0.5f) + 0.5f), 5)); + hda = (da / (float)ndivs) / 2.0f; + kappa = nvg__absf(4.0f / 3.0f * (1.0f - nvg__cosf(hda)) / nvg__sinf(hda)); + + if (dir == NVG_CCW) + kappa = -kappa; + + nvals = 0; + for (i = 0; i <= ndivs; i++) { + a = a0 + da * (i/(float)ndivs); + dx = nvg__cosf(a); + dy = nvg__sinf(a); + x = cx + dx*r; + y = cy + dy*r; + tanx = -dy*r*kappa; + tany = dx*r*kappa; + + if (i == 0) { + vals[nvals++] = (float)move; + vals[nvals++] = x; + vals[nvals++] = y; + } else { + vals[nvals++] = NVG_BEZIERTO; + vals[nvals++] = px+ptanx; + vals[nvals++] = py+ptany; + vals[nvals++] = x-tanx; + vals[nvals++] = y-tany; + vals[nvals++] = x; + vals[nvals++] = y; + } + px = x; + py = y; + ptanx = tanx; + ptany = tany; + } + + nvg__appendCommands(ctx, vals, nvals); +} + +void nvgRect(struct NVGcontext* ctx, float x, float y, float w, float h) +{ + float vals[] = { + NVG_MOVETO, x,y, + NVG_LINETO, x+w,y, + NVG_LINETO, x+w,y+h, + NVG_LINETO, x,y+h, + NVG_CLOSE + }; + nvg__appendCommands(ctx, vals, NVG_COUNTOF(vals)); +} + +void nvgRoundedRect(struct NVGcontext* ctx, float x, float y, float w, float h, float r) +{ + if (r < 0.1f) { + nvgRect(ctx, x,y,w,h); + return; + } + else { + float vals[] = { + NVG_MOVETO, x+r, y, + NVG_LINETO, x+w-r, y, + NVG_BEZIERTO, x+w-r*(1-NVG_KAPPA90), y, x+w, y+r*(1-NVG_KAPPA90), x+w, y+r, + NVG_LINETO, x+w, y+h-r, + NVG_BEZIERTO, x+w, y+h-r*(1-NVG_KAPPA90), x+w-r*(1-NVG_KAPPA90), y+h, x+w-r, y+h, + NVG_LINETO, x+r, y+h, + NVG_BEZIERTO, x+r*(1-NVG_KAPPA90), y+h, x, y+h-r*(1-NVG_KAPPA90), x, y+h-r, + NVG_LINETO, x, y+r, + NVG_BEZIERTO, x, y+r*(1-NVG_KAPPA90), x+r*(1-NVG_KAPPA90), y, x+r, y, + NVG_CLOSE + }; + nvg__appendCommands(ctx, vals, NVG_COUNTOF(vals)); + } +} + +void nvgEllipse(struct NVGcontext* ctx, float cx, float cy, float rx, float ry) +{ + float vals[] = { + NVG_MOVETO, cx+rx, cy, + NVG_BEZIERTO, cx+rx, cy+ry*NVG_KAPPA90, cx+rx*NVG_KAPPA90, cy+ry, cx, cy+ry, + NVG_BEZIERTO, cx-rx*NVG_KAPPA90, cy+ry, cx-rx, cy+ry*NVG_KAPPA90, cx-rx, cy, + NVG_BEZIERTO, cx-rx, cy-ry*NVG_KAPPA90, cx-rx*NVG_KAPPA90, cy-ry, cx, cy-ry, + NVG_BEZIERTO, cx+rx*NVG_KAPPA90, cy-ry, cx+rx, cy-ry*NVG_KAPPA90, cx+rx, cy, + NVG_CLOSE + }; + nvg__appendCommands(ctx, vals, NVG_COUNTOF(vals)); +} + +void nvgCircle(struct NVGcontext* ctx, float cx, float cy, float r) +{ + nvgEllipse(ctx, cx,cy, r,r); +} + +void nvgDebugDumpPathCache(struct NVGcontext* ctx) +{ + const struct NVGpath* path; + int i, j; + + printf("Dumping %d cached paths\n", ctx->cache->npaths); + for (i = 0; i < ctx->cache->npaths; i++) { + path = &ctx->cache->paths[i]; + printf(" - Path %d\n", i); + if (path->nfill) { + printf(" - fill: %d\n", path->nfill); + for (j = 0; j < path->nfill; j++) + printf("%f\t%f\n", path->fill[j].x, path->fill[j].y); + } + if (path->nstroke) { + printf(" - stroke: %d\n", path->nstroke); + for (j = 0; j < path->nstroke; j++) + printf("%f\t%f\n", path->stroke[j].x, path->stroke[j].y); + } + } +} + +void nvgFill(struct NVGcontext* ctx) +{ + struct NVGstate* state = nvg__getState(ctx); + const struct NVGpath* path; + int i; + + nvg__flattenPaths(ctx); + if (ctx->params.edgeAntiAlias) + nvg__expandStrokeAndFill(ctx, NVG_FILL|NVG_STROKE, ctx->fringeWidth, NVG_BUTT, NVG_MITER, 3.6f); + else + nvg__expandStrokeAndFill(ctx, NVG_FILL, 0.0f, NVG_BUTT, NVG_MITER, 1.2f); + + ctx->params.renderFill(ctx->params.userPtr, &state->fill, &state->scissor, ctx->fringeWidth, + ctx->cache->bounds, ctx->cache->paths, ctx->cache->npaths); + + // Count triangles + for (i = 0; i < ctx->cache->npaths; i++) { + path = &ctx->cache->paths[i]; + ctx->fillTriCount += path->nfill-2; + ctx->fillTriCount += path->nstroke-2; + ctx->drawCallCount += 2; + } +} + +void nvgStroke(struct NVGcontext* ctx) +{ + struct NVGstate* state = nvg__getState(ctx); + float scale = nvg__getAverageScale(state->xform); + float strokeWidth = nvg__clampf(state->strokeWidth * scale, 0.0f, 20.0f); + struct NVGpaint strokePaint = state->stroke; + const struct NVGpath* path; + int i; + + if (strokeWidth < ctx->fringeWidth) { + // If the stroke width is less than pixel size, use alpha to emulate coverate. + // Since coverage is area, scale by alpha*alpha. + float alpha = nvg__clampf(strokeWidth / ctx->fringeWidth, 0.0f, 1.0f); + strokePaint.innerColor.a *= alpha*alpha; + strokePaint.outerColor.a *= alpha*alpha; + strokeWidth = ctx->fringeWidth; + } + + nvg__flattenPaths(ctx); + if (ctx->params.edgeAntiAlias) + nvg__expandStrokeAndFill(ctx, NVG_STROKE|NVG_CAPS, strokeWidth*0.5f + ctx->fringeWidth*0.5f, state->lineCap, state->lineJoin, state->miterLimit); + else + nvg__expandStrokeAndFill(ctx, NVG_STROKE|NVG_CAPS, strokeWidth*0.5f, state->lineCap, state->lineJoin, state->miterLimit); + + ctx->params.renderStroke(ctx->params.userPtr, &strokePaint, &state->scissor, ctx->fringeWidth, + strokeWidth, ctx->cache->paths, ctx->cache->npaths); + + // Count triangles + for (i = 0; i < ctx->cache->npaths; i++) { + path = &ctx->cache->paths[i]; + ctx->strokeTriCount += path->nstroke-2; + ctx->drawCallCount++; + } +} + +// Add fonts +int nvgCreateFont(struct NVGcontext* ctx, const char* name, const char* path) +{ + return fonsAddFont(ctx->fs, name, path); +} + +int nvgCreateFontMem(struct NVGcontext* ctx, const char* name, unsigned char* data, int ndata, int freeData) +{ + return fonsAddFontMem(ctx->fs, name, data, ndata, freeData); +} + +int nvgFindFont(struct NVGcontext* ctx, const char* name) +{ + if (name == NULL) return -1; + return fonsGetFontByName(ctx->fs, name); +} + +// State setting +void nvgFontSize(struct NVGcontext* ctx, float size) +{ + struct NVGstate* state = nvg__getState(ctx); + state->fontSize = size; +} + +void nvgFontBlur(struct NVGcontext* ctx, float blur) +{ + struct NVGstate* state = nvg__getState(ctx); + state->fontBlur = blur; +} + +void nvgTextLetterSpacing(struct NVGcontext* ctx, float spacing) +{ + struct NVGstate* state = nvg__getState(ctx); + state->letterSpacing = spacing; +} + +void nvgTextLineHeight(struct NVGcontext* ctx, float lineHeight) +{ + struct NVGstate* state = nvg__getState(ctx); + state->lineHeight = lineHeight; +} + +void nvgTextAlign(struct NVGcontext* ctx, int align) +{ + struct NVGstate* state = nvg__getState(ctx); + state->textAlign = align; +} + +void nvgFontFaceId(struct NVGcontext* ctx, int font) +{ + struct NVGstate* state = nvg__getState(ctx); + state->fontId = font; +} + +void nvgFontFace(struct NVGcontext* ctx, const char* font) +{ + struct NVGstate* state = nvg__getState(ctx); + state->fontId = fonsGetFontByName(ctx->fs, font); +} + +static float nvg__quantize(float a, float d) +{ + return ((int)(a / d + 0.5f)) * d; +} + +static float nvg__getFontScale(struct NVGstate* state) +{ + return nvg__minf(nvg__quantize(nvg__getAverageScale(state->xform), 0.01f), 4.0f); +} + +float nvgText(struct NVGcontext* ctx, float x, float y, const char* string, const char* end) +{ + struct NVGstate* state = nvg__getState(ctx); + struct NVGpaint paint; + struct FONStextIter iter; + struct FONSquad q; + struct NVGvertex* verts; + float scale = nvg__getFontScale(state) * ctx->devicePxRatio; + float invscale = 1.0f / scale; + int dirty[4]; + int cverts = 0; + int nverts = 0; + + if (end == NULL) + end = string + strlen(string); + + if (state->fontId == FONS_INVALID) return x; + + fonsSetSize(ctx->fs, state->fontSize*scale); + fonsSetSpacing(ctx->fs, state->letterSpacing*scale); + fonsSetBlur(ctx->fs, state->fontBlur*scale); + fonsSetAlign(ctx->fs, state->textAlign); + fonsSetFont(ctx->fs, state->fontId); + + cverts = nvg__maxi(2, (int)(end - string)) * 6; // conservative estimate. + verts = nvg__allocTempVerts(ctx, cverts); + if (verts == NULL) return x; + + fonsTextIterInit(ctx->fs, &iter, x*scale, y*scale, string, end); + while (fonsTextIterNext(ctx->fs, &iter, &q)) { + // Trasnform corners. + float c[4*2]; + nvgTransformPoint(&c[0],&c[1], state->xform, q.x0*invscale, q.y0*invscale); + nvgTransformPoint(&c[2],&c[3], state->xform, q.x1*invscale, q.y0*invscale); + nvgTransformPoint(&c[4],&c[5], state->xform, q.x1*invscale, q.y1*invscale); + nvgTransformPoint(&c[6],&c[7], state->xform, q.x0*invscale, q.y1*invscale); + // Create triangles + if (nverts+6 <= cverts) { + nvg__vset(&verts[nverts], c[0], c[1], q.s0, q.t0); nverts++; + nvg__vset(&verts[nverts], c[4], c[5], q.s1, q.t1); nverts++; + nvg__vset(&verts[nverts], c[2], c[3], q.s1, q.t0); nverts++; + nvg__vset(&verts[nverts], c[0], c[1], q.s0, q.t0); nverts++; + nvg__vset(&verts[nverts], c[6], c[7], q.s0, q.t1); nverts++; + nvg__vset(&verts[nverts], c[4], c[5], q.s1, q.t1); nverts++; + } + } + + // TODO: add back-end bit to do this just once per frame. + if (fonsValidateTexture(ctx->fs, dirty)) { + // Update texture + if (ctx->fontImage != 0) { + int iw, ih; + const unsigned char* data = fonsGetTextureData(ctx->fs, &iw, &ih); + int x = dirty[0]; + int y = dirty[1]; + int w = dirty[2] - dirty[0]; + int h = dirty[3] - dirty[1]; + ctx->params.renderUpdateTexture(ctx->params.userPtr, ctx->fontImage, x,y, w,h, data); + } + } + + // Render triangles. + paint = state->fill; + paint.image = ctx->fontImage; + ctx->params.renderTriangles(ctx->params.userPtr, &paint, &state->scissor, verts, nverts); + + ctx->drawCallCount++; + ctx->textTriCount += nverts/3; + + return iter.x; +} + +void nvgTextBox(struct NVGcontext* ctx, float x, float y, float breakRowWidth, const char* string, const char* end) +{ + struct NVGstate* state = nvg__getState(ctx); + struct NVGtextRow rows[2]; + int nrows = 0, i; + int oldAlign = state->textAlign; + int haling = state->textAlign & (NVG_ALIGN_LEFT | NVG_ALIGN_CENTER | NVG_ALIGN_RIGHT); + int valign = state->textAlign & (NVG_ALIGN_TOP | NVG_ALIGN_MIDDLE | NVG_ALIGN_BOTTOM | NVG_ALIGN_BASELINE); + float lineh = 0; + + if (state->fontId == FONS_INVALID) return; + + nvgTextMetrics(ctx, NULL, NULL, &lineh); + + state->textAlign = NVG_ALIGN_LEFT | valign; + + while ((nrows = nvgTextBreakLines(ctx, string, end, breakRowWidth, rows, 2))) { + for (i = 0; i < nrows; i++) { + struct NVGtextRow* row = &rows[i]; + if (haling & NVG_ALIGN_LEFT) + nvgText(ctx, x, y, row->start, row->end); + else if (haling & NVG_ALIGN_CENTER) + nvgText(ctx, x + breakRowWidth*0.5f - row->width*0.5f, y, row->start, row->end); + else if (haling & NVG_ALIGN_RIGHT) + nvgText(ctx, x + breakRowWidth - row->width, y, row->start, row->end); + y += lineh * state->lineHeight; + } + string = rows[nrows-1].next; + } + + state->textAlign = oldAlign; +} + +int nvgTextGlyphPositions(struct NVGcontext* ctx, float x, float y, const char* string, const char* end, struct NVGglyphPosition* positions, int maxPositions) +{ + struct NVGstate* state = nvg__getState(ctx); + float scale = nvg__getFontScale(state) * ctx->devicePxRatio; + float invscale = 1.0f / scale; + struct FONStextIter iter; + struct FONSquad q; + int npos = 0; + + if (state->fontId == FONS_INVALID) return 0; + + if (end == NULL) + end = string + strlen(string); + + if (string == end) + return 0; + + fonsSetSize(ctx->fs, state->fontSize*scale); + fonsSetSpacing(ctx->fs, state->letterSpacing*scale); + fonsSetBlur(ctx->fs, state->fontBlur*scale); + fonsSetAlign(ctx->fs, state->textAlign); + fonsSetFont(ctx->fs, state->fontId); + + fonsTextIterInit(ctx->fs, &iter, x*scale, y*scale, string, end); + while (fonsTextIterNext(ctx->fs, &iter, &q)) { + positions[npos].str = iter.str; + positions[npos].x = iter.x * invscale; + positions[npos].minx = q.x0 * invscale; + positions[npos].maxx = q.x1 * invscale; + npos++; + if (npos >= maxPositions) + break; + } + + return npos; +} + +enum NVGcodepointType { + NVG_SPACE, + NVG_NEWLINE, + NVG_CHAR, +}; + +int nvgTextBreakLines(struct NVGcontext* ctx, const char* string, const char* end, float breakRowWidth, struct NVGtextRow* rows, int maxRows) +{ + struct NVGstate* state = nvg__getState(ctx); + float scale = nvg__getFontScale(state) * ctx->devicePxRatio; + float invscale = 1.0f / scale; + struct FONStextIter iter; + struct FONSquad q; + int nrows = 0; + float rowStartX = 0; + float rowWidth = 0; + float rowMinX = 0; + float rowMaxX = 0; + const char* rowStart = NULL; + const char* rowEnd = NULL; + const char* wordStart = NULL; + float wordStartX = 0; + float wordMinX = 0; + const char* breakEnd = NULL; + float breakWidth = 0; + float breakMaxX = 0; + int type = NVG_SPACE, ptype = NVG_SPACE; + unsigned int pcodepoint = 0; + + if (maxRows == 0) return 0; + if (state->fontId == FONS_INVALID) return 0; + + if (end == NULL) + end = string + strlen(string); + + if (string == end) return 0; + + fonsSetSize(ctx->fs, state->fontSize*scale); + fonsSetSpacing(ctx->fs, state->letterSpacing*scale); + fonsSetBlur(ctx->fs, state->fontBlur*scale); + fonsSetAlign(ctx->fs, state->textAlign); + fonsSetFont(ctx->fs, state->fontId); + + breakRowWidth *= scale; + + fonsTextIterInit(ctx->fs, &iter, 0, 0, string, end); + while (fonsTextIterNext(ctx->fs, &iter, &q)) { + switch (iter.codepoint) { + case 9: // \t + case 11: // \v + case 12: // \f + case 32: // space + case 0x00a0: // NBSP + type = NVG_SPACE; + break; + case 10: // \n + type = pcodepoint == 13 ? NVG_SPACE : NVG_NEWLINE; + break; + case 13: // \r + type = pcodepoint == 10 ? NVG_SPACE : NVG_NEWLINE; + break; + case 0x0085: // NEL + type = NVG_NEWLINE; + break; + default: + type = NVG_CHAR; + break; + } + + if (type == NVG_NEWLINE) { + // Always handle new lines. + rows[nrows].start = rowStart != NULL ? rowStart : iter.str; + rows[nrows].end = rowEnd != NULL ? rowEnd : iter.str; + rows[nrows].width = rowWidth * invscale; + rows[nrows].minx = rowMinX * invscale; + rows[nrows].maxx = rowMaxX * invscale; + rows[nrows].next = iter.next; + nrows++; + if (nrows >= maxRows) + return nrows; + // Set null break point + breakEnd = rowStart; + breakWidth = 0.0; + breakMaxX = 0.0; + // Indicate to skip the white space at the beginning of the row. + rowStart = NULL; + rowEnd = NULL; + rowWidth = 0; + rowMinX = rowMaxX = 0; + } else { + if (rowStart == NULL) { + // Skip white space until the beginning of the line + if (type == NVG_CHAR) { + // The current char is the row so far + rowStartX = iter.x; + rowStart = iter.str; + rowEnd = iter.next; + rowWidth = iter.nextx - rowStartX; // q.x1 - rowStartX; + rowMinX = q.x0 - rowStartX; + rowMaxX = q.x1 - rowStartX; + wordStart = iter.str; + wordStartX = iter.x; + wordMinX = q.x0 - rowStartX; + // Set null break point + breakEnd = rowStart; + breakWidth = 0.0; + breakMaxX = 0.0; + } + } else { + float nextWidth = iter.nextx - rowStartX; //q.x1 - rowStartX; + + if (nextWidth > breakRowWidth) { + // The run length is too long, need to break to new line. + if (breakEnd == rowStart) { + // The current word is longer than the row length, just break it from here. + rows[nrows].start = rowStart; + rows[nrows].end = iter.str; + rows[nrows].width = rowWidth * invscale; + rows[nrows].minx = rowMinX * invscale; + rows[nrows].maxx = rowMaxX * invscale; + rows[nrows].next = iter.str; + nrows++; + if (nrows >= maxRows) + return nrows; + rowStartX = iter.x; + rowStart = iter.str; + rowEnd = iter.next; + rowWidth = iter.nextx - rowStartX; + rowMinX = q.x0 - rowStartX; + rowMaxX = q.x1 - rowStartX; + wordStart = iter.str; + wordStartX = iter.x; + wordMinX = q.x0 - rowStartX; + } else { + // Break the line from the end of the last word, and start new line from the begining of the new. + rows[nrows].start = rowStart; + rows[nrows].end = breakEnd; + rows[nrows].width = breakWidth * invscale; + rows[nrows].minx = rowMinX * invscale; + rows[nrows].maxx = breakMaxX * invscale; + rows[nrows].next = wordStart; + nrows++; + if (nrows >= maxRows) + return nrows; + rowStartX = wordStartX; + rowStart = wordStart; + rowEnd = iter.next; + rowWidth = iter.nextx - rowStartX; // q.x1 - rowStartX; + rowMinX = wordMinX; + rowMaxX = q.x1 - rowStartX; + // No change to the word start + } + // Set null break point + breakEnd = rowStart; + breakWidth = 0.0; + breakMaxX = 0.0; + } + + // track last non-white space character + if (type == NVG_CHAR) { + rowEnd = iter.next; + rowWidth = iter.nextx - rowStartX; // q.x1 - rowStartX; + rowMaxX = q.x1 - rowStartX; + } + // track last end of a word + if (ptype == NVG_CHAR && (type == NVG_SPACE || type == NVG_SPACE)) { + breakEnd = iter.str; + breakWidth = rowWidth; + breakMaxX = rowMaxX; + } + // track last beginning of a word + if ((ptype == NVG_SPACE || ptype == NVG_SPACE) && type == NVG_CHAR) { + wordStart = iter.str; + wordStartX = iter.x; + wordMinX = q.x0 - rowStartX; + } + } + } + + pcodepoint = iter.codepoint; + ptype = type; + } + + // Break the line from the end of the last word, and start new line from the begining of the new. + if (rowStart != NULL) { + rows[nrows].start = rowStart; + rows[nrows].end = rowEnd; + rows[nrows].width = rowWidth * invscale; + rows[nrows].minx = rowMinX * invscale; + rows[nrows].maxx = rowMaxX * invscale; + rows[nrows].next = end; + nrows++; + } + + return nrows; +} + +float nvgTextBounds(struct NVGcontext* ctx, float x, float y, const char* string, const char* end, float* bounds) +{ + struct NVGstate* state = nvg__getState(ctx); + float scale = nvg__getFontScale(state) * ctx->devicePxRatio; + float invscale = 1.0f / scale; + float width; + + if (state->fontId == FONS_INVALID) return 0; + + fonsSetSize(ctx->fs, state->fontSize*scale); + fonsSetSpacing(ctx->fs, state->letterSpacing*scale); + fonsSetBlur(ctx->fs, state->fontBlur*scale); + fonsSetAlign(ctx->fs, state->textAlign); + fonsSetFont(ctx->fs, state->fontId); + + width = fonsTextBounds(ctx->fs, x, y, string, end, bounds); + if (bounds != NULL) { + bounds[0] *= invscale; + bounds[1] *= invscale; + bounds[2] *= invscale; + bounds[3] *= invscale; + } + return width * invscale; +} + +void nvgTextBoxBounds(struct NVGcontext* ctx, float x, float y, float breakRowWidth, const char* string, const char* end, float* bounds) +{ + struct NVGstate* state = nvg__getState(ctx); + struct NVGtextRow rows[2]; + float scale = nvg__getFontScale(state) * ctx->devicePxRatio; + float invscale = 1.0f / scale; + int nrows = 0, i; + int oldAlign = state->textAlign; + int haling = state->textAlign & (NVG_ALIGN_LEFT | NVG_ALIGN_CENTER | NVG_ALIGN_RIGHT); + int valign = state->textAlign & (NVG_ALIGN_TOP | NVG_ALIGN_MIDDLE | NVG_ALIGN_BOTTOM | NVG_ALIGN_BASELINE); + float lineh = 0, rminy = 0, rmaxy = 0; + float minx, miny, maxx, maxy; + + if (state->fontId == FONS_INVALID) { + if (bounds != NULL) + bounds[0] = bounds[1] = bounds[2] = bounds[3] = 0.0f; + return; + } + + nvgTextMetrics(ctx, NULL, NULL, &lineh); + + nvgTextMetrics(ctx, NULL, NULL, &lineh); + + state->textAlign = NVG_ALIGN_LEFT | valign; + + minx = maxx = x; + miny = maxy = y; + + fonsSetSize(ctx->fs, state->fontSize*scale); + fonsSetSpacing(ctx->fs, state->letterSpacing*scale); + fonsSetBlur(ctx->fs, state->fontBlur*scale); + fonsSetAlign(ctx->fs, state->textAlign); + fonsSetFont(ctx->fs, state->fontId); + fonsLineBounds(ctx->fs, 0, &rminy, &rmaxy); + rminy *= invscale; + rmaxy *= invscale; + + while ((nrows = nvgTextBreakLines(ctx, string, end, breakRowWidth, rows, 2))) { + for (i = 0; i < nrows; i++) { + struct NVGtextRow* row = &rows[i]; + float rminx, rmaxx, dx = 0; + // Horizontal bounds + if (haling & NVG_ALIGN_LEFT) + dx = 0; + else if (haling & NVG_ALIGN_CENTER) + dx = breakRowWidth*0.5f - row->width*0.5f; + else if (haling & NVG_ALIGN_RIGHT) + dx = breakRowWidth - row->width; + rminx = x + row->minx + dx; + rmaxx = x + row->maxx + dx; + minx = nvg__minf(minx, rminx); + maxx = nvg__maxf(maxx, rmaxx); + // Vertical bounds. + miny = nvg__minf(miny, y + rminy); + maxy = nvg__maxf(maxy, y + rmaxy); + + y += lineh * state->lineHeight; + } + string = rows[nrows-1].next; + } + + state->textAlign = oldAlign; + + if (bounds != NULL) { + bounds[0] = minx; + bounds[1] = miny; + bounds[2] = maxx; + bounds[3] = maxy; + } +} + +void nvgTextMetrics(struct NVGcontext* ctx, float* ascender, float* descender, float* lineh) +{ + struct NVGstate* state = nvg__getState(ctx); + float scale = nvg__getFontScale(state) * ctx->devicePxRatio; + float invscale = 1.0f / scale; + + if (state->fontId == FONS_INVALID) return; + + fonsSetSize(ctx->fs, state->fontSize*scale); + fonsSetSpacing(ctx->fs, state->letterSpacing*scale); + fonsSetBlur(ctx->fs, state->fontBlur*scale); + fonsSetAlign(ctx->fs, state->textAlign); + fonsSetFont(ctx->fs, state->fontId); + + fonsVertMetrics(ctx->fs, ascender, descender, lineh); + if (ascender != NULL) + *ascender *= invscale; + if (descender != NULL) + *descender *= invscale; + if (lineh != NULL) + *lineh *= invscale; +} diff --git a/libs/dgl/src/nanovg/nanovg.h b/libs/dgl/src/nanovg/nanovg.h new file mode 100644 index 0000000..247a9ee --- /dev/null +++ b/libs/dgl/src/nanovg/nanovg.h @@ -0,0 +1,590 @@ +// +// Copyright (c) 2013 Mikko Mononen memon@inside.org +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. +// + +#ifndef NANOVG_H +#define NANOVG_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define NVG_PI 3.14159265358979323846264338327f + +struct NVGcontext; + +struct NVGcolor { + union { + float rgba[4]; + struct { + float r,g,b,a; + }; + }; +}; + +struct NVGpaint { + float xform[6]; + float extent[2]; + float radius; + float feather; + struct NVGcolor innerColor; + struct NVGcolor outerColor; + int image; + int repeat; +}; + +enum NVGwinding { + NVG_CCW = 1, // Winding for solid shapes + NVG_CW = 2, // Winding for holes +}; + +enum NVGsolidity { + NVG_SOLID = 1, // CCW + NVG_HOLE = 2, // CW +}; + +enum NVGlineCap { + NVG_BUTT, + NVG_ROUND, + NVG_SQUARE, + NVG_BEVEL, + NVG_MITER, +}; + +enum NVGpatternRepeat { + NVG_REPEATX = 0x01, // Repeat image pattern in X direction + NVG_REPEATY = 0x02, // Repeat image pattern in Y direction +}; + +enum NVGalign { + // Horizontal align + NVG_ALIGN_LEFT = 1<<0, // Default, align text horizontally to left. + NVG_ALIGN_CENTER = 1<<1, // Align text horizontally to center. + NVG_ALIGN_RIGHT = 1<<2, // Align text horizontally to right. + // Vertical align + NVG_ALIGN_TOP = 1<<3, // Align text vertically to top. + NVG_ALIGN_MIDDLE = 1<<4, // Align text vertically to middle. + NVG_ALIGN_BOTTOM = 1<<5, // Align text vertically to bottom. + NVG_ALIGN_BASELINE = 1<<6, // Default, align text vertically to baseline. +}; + +enum NVGalpha { + NVG_STRAIGHT_ALPHA, + NVG_PREMULTIPLIED_ALPHA, +}; + +struct NVGglyphPosition { + const char* str; // Position of the glyph in the input string. + float x; // The x-coordinate of the logical glyph position. + float minx, maxx; // The bounds of the glyph shape. +}; + +struct NVGtextRow { + const char* start; // Pointer to the input text where the row starts. + const char* end; // Pointer to the input text where the row ends (one past the last character). + const char* next; // Pointer to the beginning of the next row. + float width; // Logical width of the row. + float minx, maxx; // Actual bounds of the row. Logical with and bounds can differ because of kerning and some parts over extending. +}; + + +// Begin drawing a new frame +// Calls to nanovg drawing API should be wrapped in nvgBeginFrame() & nvgEndFrame() +// nvgBeginFrame() defines the size of the window to render to in relation currently +// set viewport (i.e. glViewport on GL backends). Device pixel ration allows to +// control the rendering on Hi-DPI devices. +// For example, GLFW returns two dimension for an opened window: window size and +// frame buffer size. In that case you would set windowWidth/Height to the window size +// devicePixelRatio to: frameBufferWidth / windowWidth. +// AlphaBlend controls if drawing the shapes to the render target should be done using straight or +// premultiplied alpha. If rendering directly to framebuffer you probably want to use NVG_STRAIGHT_ALPHA, +// if rendering to texture which should contain transparent regions NVG_PREMULTIPLIED_ALPHA is the +// right choice. +void nvgBeginFrame(struct NVGcontext* ctx, int windowWidth, int windowHeight, float devicePixelRatio, int alphaBlend); + +// Ends drawing flushing remaining render state. +void nvgEndFrame(struct NVGcontext* ctx); + +// +// Color utils +// +// Colors in NanoVG are stored as unsigned ints in ABGR format. + +// Returns a color value from red, green, blue values. Alpha will be set to 255 (1.0f). +struct NVGcolor nvgRGB(unsigned char r, unsigned char g, unsigned char b); + +// Returns a color value from red, green, blue values. Alpha will be set to 1.0f. +struct NVGcolor nvgRGBf(float r, float g, float b); + + +// Returns a color value from red, green, blue and alpha values. +struct NVGcolor nvgRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a); + +// Returns a color value from red, green, blue and alpha values. +struct NVGcolor nvgRGBAf(float r, float g, float b, float a); + + +// Linearly interpoaltes from color c0 to c1, and returns resulting color value. +struct NVGcolor nvgLerpRGBA(struct NVGcolor c0, struct NVGcolor c1, float u); + +// Sets transparency of a color value. +struct NVGcolor nvgTransRGBA(struct NVGcolor c0, unsigned char a); + +// Sets transparency of a color value. +struct NVGcolor nvgTransRGBAf(struct NVGcolor c0, float a); + +// Returns color value specified by hue, saturation and lightness. +// HSL values are all in range [0..1], alpha will be set to 255. +struct NVGcolor nvgHSL(float h, float s, float l); + +// Returns color value specified by hue, saturation and lightness and alpha. +// HSL values are all in range [0..1], alpha in range [0..255] +struct NVGcolor nvgHSLA(float h, float s, float l, unsigned char a); + +// +// State Handling +// +// NanoVG contains state which represents how paths will be rendered. +// The state contains transform, fill and stroke styles, text and font styles, +// and scissor clipping. + +// Pushes and saves the current render state into a state stack. +// A matching nvgRestore() must be used to restore the state. +void nvgSave(struct NVGcontext* ctx); + +// Pops and restores current render state. +void nvgRestore(struct NVGcontext* ctx); + +// Resets current render state to default values. Does not affect the render state stack. +void nvgReset(struct NVGcontext* ctx); + +// +// Render styles +// +// Fill and stroke render style can be either a solid color or a paint which is a gradient or a pattern. +// Solid color is simply defined as a color value, different kinds of paints can be created +// using nvgLinearGradient(), nvgBoxGradient(), nvgRadialGradient() and nvgImagePattern(). +// +// Current render style can be saved and restored using nvgSave() and nvgRestore(). + +// Sets current stroke style to a solid color. +void nvgStrokeColor(struct NVGcontext* ctx, struct NVGcolor color); + +// Sets current stroke style to a paint, which can be a one of the gradients or a pattern. +void nvgStrokePaint(struct NVGcontext* ctx, struct NVGpaint paint); + +// Sets current fill cstyle to a solid color. +void nvgFillColor(struct NVGcontext* ctx, struct NVGcolor color); + +// Sets current fill style to a paint, which can be a one of the gradients or a pattern. +void nvgFillPaint(struct NVGcontext* ctx, struct NVGpaint paint); + +// Sets the miter limit of the stroke style. +// Miter limit controls when a sharp corner is beveled. +void nvgMiterLimit(struct NVGcontext* ctx, float limit); + +// Sets the stroke witdth of the stroke style. +void nvgStrokeWidth(struct NVGcontext* ctx, float size); + +// Sets how the end of the line (cap) is drawn, +// Can be one of: NVG_BUTT (default), NVG_ROUND, NVG_SQUARE. +void nvgLineCap(struct NVGcontext* ctx, int cap); + +// Sets how sharp path corners are drawn. +// Can be one of NVG_MITER (default), NVG_ROUND, NVG_BEVEL. +void nvgLineJoin(struct NVGcontext* ctx, int join); + +// +// Transforms +// +// The paths, gradients, patterns and scissor region are transformed by an transformation +// matrix at the time when they are passed to the API. +// The current transformation matrix is a affine matrix: +// [sx kx tx] +// [ky sy ty] +// [ 0 0 1] +// Where: sx,sy define scaling, kx,ky skewing, and tx,ty translation. +// The last row is assumed to be 0,0,1 and is not stored. +// +// Apart from nvgResetTransform(), each transformation function first creates +// specific transformation matrix and pre-multiplies the current transformation by it. +// +// Current coordinate system (transformation) can be saved and restored using nvgSave() and nvgRestore(). + +// Resets current transform to a identity matrix. +void nvgResetTransform(struct NVGcontext* ctx); + +// Premultiplies current coordinate system by specified matrix. +// The parameters are interpreted as matrix as follows: +// [a c e] +// [b d f] +// [0 0 1] +void nvgTransform(struct NVGcontext* ctx, float a, float b, float c, float d, float e, float f); + +// Translates current coordinate system. +void nvgTranslate(struct NVGcontext* ctx, float x, float y); + +// Rotates current coordinate system. Angle is specifid in radians. +void nvgRotate(struct NVGcontext* ctx, float angle); + +// Skews the current coordinate system along X axis. Angle is specifid in radians. +void nvgSkewX(struct NVGcontext* ctx, float angle); + +// Skews the current coordinate system along Y axis. Angle is specifid in radians. +void nvgSkewY(struct NVGcontext* ctx, float angle); + +// Scales the current coordinat system. +void nvgScale(struct NVGcontext* ctx, float x, float y); + +// Stores the top part (a-f) of the current transformation matrix in to the specified buffer. +// [a c e] +// [b d f] +// [0 0 1] +// There should be space for 6 floats in the return buffer for the values a-f. +void nvgCurrentTransform(struct NVGcontext* ctx, float* xform); + + +// The following functions can be used to make calculations on 2x3 transformation matrices. +// A 2x3 matrix is representated as float[6]. + +// Sets the transform to identity matrix. +void nvgTransformIdentity(float* dst); + +// Sets the transform to translation matrix matrix. +void nvgTransformTranslate(float* dst, float tx, float ty); + +// Sets the transform to scale matrix. +void nvgTransformScale(float* dst, float sx, float sy); + +// Sets the transform to rotate matrix. Angle is specifid in radians. +void nvgTransformRotate(float* dst, float a); + +// Sets the transform to skew-x matrix. Angle is specifid in radians. +void nvgTransformSkewX(float* dst, float a); + +// Sets the transform to skew-y matrix. Angle is specifid in radians. +void nvgTransformSkewY(float* dst, float a); + +// Sets the transform to the result of multiplication of two transforms, of A = A*B. +void nvgTransformMultiply(float* dst, const float* src); + +// Sets the transform to the result of multiplication of two transforms, of A = B*A. +void nvgTransformPremultiply(float* dst, const float* src); + +// Sets the destination to inverse of specified transform. +// Returns 1 if the inverse could be calculated, else 0. +int nvgTransformInverse(float* dst, const float* src); + +// Transform a point by given transform. +void nvgTransformPoint(float* dstx, float* dsty, const float* xform, float srcx, float srcy); + +// Converts degress to radians and vice versa. +float nvgDegToRad(float deg); +float nvgRadToDeg(float rad); + +// +// Images +// +// NanoVG allows you to load jpg, png, psd, tga, pic and gif files to be used for rendering. +// In addition you can upload your own image. The image loading is provided by stb_image. + +// Creates image by loading it from the disk from specified file name. +// Returns handle to the image. +int nvgCreateImage(struct NVGcontext* ctx, const char* filename); + +// Creates image by loading it from the specified chunk of memory. +// Returns handle to the image. +int nvgCreateImageMem(struct NVGcontext* ctx, unsigned char* data, int ndata); + +// Creates image from specified image data. +// Returns handle to the image. +int nvgCreateImageRGBA(struct NVGcontext* ctx, int w, int h, const unsigned char* data); + +// Updates image data specified by image handle. +void nvgUpdateImage(struct NVGcontext* ctx, int image, const unsigned char* data); + +// Returns the domensions of a created image. +void nvgImageSize(struct NVGcontext* ctx, int image, int* w, int* h); + +// Deletes created image. +void nvgDeleteImage(struct NVGcontext* ctx, int image); + +// +// Paints +// +// NanoVG supports four types of paints: linear gradient, box gradient, radial gradient and image pattern. +// These can be used as paints for strokes and fills. + +// Creates and returns a linear gradient. Parameters (sx,sy)-(ex,ey) specify the start and end coordinates +// of the linear gradient, icol specifies the start color and ocol the end color. +// The gradient is transformed by the current transform when it is passed to nvgFillPaint() or nvgStrokePaint(). +struct NVGpaint nvgLinearGradient(struct NVGcontext* ctx, float sx, float sy, float ex, float ey, + struct NVGcolor icol, struct NVGcolor ocol); + +// Creates and returns a box gradient. Box gradient is a feathered rounded rectangle, it is useful for rendering +// drop shadows or hilights for boxes. Parameters (x,y) define the top-left corner of the rectangle, +// (w,h) define the size of the rectangle, r defines the corner radius, and f feather. Feather defines how blurry +// the border of the rectangle is. Parameter icol specifies the inner color and ocol the outer color of the gradient. +// The gradient is transformed by the current transform when it is passed to nvgFillPaint() or nvgStrokePaint(). +struct NVGpaint nvgBoxGradient(struct NVGcontext* ctx, float x, float y, float w, float h, + float r, float f, struct NVGcolor icol, struct NVGcolor ocol); + +// Creates and returns a radial gradient. Parameters (cx,cy) specify the center, inr and outr specify +// the inner and outer radius of the gradient, icol specifies the start color and ocol the end color. +// The gradient is transformed by the current transform when it is passed to nvgFillPaint() or nvgStrokePaint(). +struct NVGpaint nvgRadialGradient(struct NVGcontext* ctx, float cx, float cy, float inr, float outr, + struct NVGcolor icol, struct NVGcolor ocol); + +// Creates and returns an image patter. Parameters (ox,oy) specify the left-top location of the image pattern, +// (ex,ey) the size of one image, angle rotation around the top-left corner, image is handle to the image to render, +// and repeat is combination of NVG_REPEATX and NVG_REPEATY which tells if the image should be repeated across x or y. +// The gradient is transformed by the current transform when it is passed to nvgFillPaint() or nvgStrokePaint(). +struct NVGpaint nvgImagePattern(struct NVGcontext* ctx, float ox, float oy, float ex, float ey, + float angle, int image, int repeat); + +// +// Scissoring +// +// Scissoring allows you to clip the rendering into a rectangle. This is useful for varius +// user interface cases like rendering a text edit or a timeline. + +// Sets the current +// The scissor rectangle is transformed by the current transform. +void nvgScissor(struct NVGcontext* ctx, float x, float y, float w, float h); + +// Reset and disables scissoring. +void nvgResetScissor(struct NVGcontext* ctx); + +// +// Paths +// +// Drawing a new shape starts with nvgBeginPath(), it clears all the currently defined paths. +// Then you define one or more paths and sub-paths which describe the shape. The are functions +// to draw common shapes like rectangles and circles, and lower level step-by-step functions, +// which allow to define a path curve by curve. +// +// NanoVG uses even-odd fill rule to draw the shapes. Solid shapes should have counter clockwise +// winding and holes should have counter clockwise order. To specify winding of a path you can +// call nvgPathWinding(). This is useful especially for the common shapes, which are drawn CCW. +// +// Finally you can fill the path using current fill style by calling nvgFill(), and stroke it +// with current stroke style by calling nvgStroke(). +// +// The curve segments and sub-paths are transformed by the current transform. + +// Clears the current path and sub-paths. +void nvgBeginPath(struct NVGcontext* ctx); + +// Starts new sub-path with specified point as first point. +void nvgMoveTo(struct NVGcontext* ctx, float x, float y); + +// Adds line segment from the last point in the path to the specified point. +void nvgLineTo(struct NVGcontext* ctx, float x, float y); + +// Adds bezier segment from last point in the path via two control points to the specified point. +void nvgBezierTo(struct NVGcontext* ctx, float c1x, float c1y, float c2x, float c2y, float x, float y); + +// Adds an arc segment at the corner defined by the last path point, and two specified points. +void nvgArcTo(struct NVGcontext* ctx, float x1, float y1, float x2, float y2, float radius); + +// Closes current sub-path with a line segment. +void nvgClosePath(struct NVGcontext* ctx); + +// Sets the current sub-path winding, see NVGwinding and NVGsolidity. +void nvgPathWinding(struct NVGcontext* ctx, int dir); + +// Creates new arc shaped sub-path. +void nvgArc(struct NVGcontext* ctx, float cx, float cy, float r, float a0, float a1, int dir); + +// Creates new rectangle shaped sub-path. +void nvgRect(struct NVGcontext* ctx, float x, float y, float w, float h); + +// Creates new rounded rectangle shaped sub-path. +void nvgRoundedRect(struct NVGcontext* ctx, float x, float y, float w, float h, float r); + +// Creates new ellipse shaped sub-path. +void nvgEllipse(struct NVGcontext* ctx, float cx, float cy, float rx, float ry); + +// Creates new circle shaped sub-path. +void nvgCircle(struct NVGcontext* ctx, float cx, float cy, float r); + +// Fills the current path with current fill style. +void nvgFill(struct NVGcontext* ctx); + +// Fills the current path with current stroke style. +void nvgStroke(struct NVGcontext* ctx); + + +// +// Text +// +// NanoVG allows you to load .ttf files and use the font to render text. +// +// The appearance of the text can be defined by setting the current text style +// and by specifying the fill color. Common text and font settings such as +// font size, letter spacing and text align are supported. Font blur allows you +// to create simple text effects such as drop shadows. +// +// At render time the font face can be set based on the font handles or name. +// +// Font measure functions return values in local space, the calculations are +// carried in the same resolution as the final rendering. This is done because +// the text glyph positions are snapped to the nearest pixels sharp rendering. +// +// The local space means that values are not rotated or scale as per the current +// transformation. For example if you set font size to 12, which would mean that +// line height is 16, then regardless of the current scaling and rotation, the +// returned line height is always 16. Some measures may vary because of the scaling +// since aforementioned pixel snapping. +// +// While this may sound a little odd, the setup allows you to always render the +// same way regardless of scaling. I.e. following works regardless of scaling: +// +// const char* txt = "Text me up."; +// nvgTextBounds(vg, x,y, txt, NULL, bounds); +// nvgBeginPath(vg); +// nvgRoundedRect(vg, bounds[0],bounds[1], bounds[2]-bounds[0], bounds[3]-bounds[1]); +// nvgFill(vg); +// +// Note: currently only solid color fill is supported for text. + +// Creates font by loading it from the disk from specified file name. +// Returns handle to the font. +int nvgCreateFont(struct NVGcontext* ctx, const char* name, const char* filename); + +// Creates image by loading it from the specified memory chunk. +// Returns handle to the font. +int nvgCreateFontMem(struct NVGcontext* ctx, const char* name, unsigned char* data, int ndata, int freeData); + +// Finds a loaded font of specified name, and returns handle to it, or -1 if the font is not found. +int nvgFindFont(struct NVGcontext* ctx, const char* name); + +// Sets the font size of current text style. +void nvgFontSize(struct NVGcontext* ctx, float size); + +// Sets the blur of current text style. +void nvgFontBlur(struct NVGcontext* ctx, float blur); + +// Sets the letter spacing of current text style. +void nvgTextLetterSpacing(struct NVGcontext* ctx, float spacing); + +// Sets the proportional line height of current text style. The line height is specified as multiple of font size. +void nvgTextLineHeight(struct NVGcontext* ctx, float lineHeight); + +// Sets the text align of current text style, see NVGaling for options. +void nvgTextAlign(struct NVGcontext* ctx, int align); + +// Sets the font face based on specified id of current text style. +void nvgFontFaceId(struct NVGcontext* ctx, int font); + +// Sets the font face based on specified name of current text style. +void nvgFontFace(struct NVGcontext* ctx, const char* font); + +// Draws text string at specified location. If end is specified only the sub-string up to the end is drawn. +float nvgText(struct NVGcontext* ctx, float x, float y, const char* string, const char* end); + +// Draws multi-line text string at specified location wrapped at the specified width. If end is specified only the sub-string up to the end is drawn. +// White space is stripped at the beginning of the rows, the text is split at word boundaries or when new-line characters are encountered. +// Words longer than the max width are slit at nearest character (i.e. no hyphenation). +void nvgTextBox(struct NVGcontext* ctx, float x, float y, float breakRowWidth, const char* string, const char* end); + +// Measures the specified text string. Parameter bounds should be a pointer to float[4], +// if the bounding box of the text should be returned. The bounds value are [xmin,ymin, xmax,ymax] +// Returns the horizontal advance of the measured text (i.e. where the next character should drawn). +// Measured values are returned in local coordinate space. +float nvgTextBounds(struct NVGcontext* ctx, float x, float y, const char* string, const char* end, float* bounds); + +// Measures the specified multi-text string. Parameter bounds should be a pointer to float[4], +// if the bounding box of the text should be returned. The bounds value are [xmin,ymin, xmax,ymax] +// Measured values are returned in local coordinate space. +void nvgTextBoxBounds(struct NVGcontext* ctx, float x, float y, float breakRowWidth, const char* string, const char* end, float* bounds); + +// Calculates the glyph x positions of the specified text. If end is specified only the sub-string will be used. +// Measured values are returned in local coordinate space. +int nvgTextGlyphPositions(struct NVGcontext* ctx, float x, float y, const char* string, const char* end, struct NVGglyphPosition* positions, int maxPositions); + +// Returns the vertical metrics based on the current text style. +// Measured values are returned in local coordinate space. +void nvgTextMetrics(struct NVGcontext* ctx, float* ascender, float* descender, float* lineh); + +// Breaks the specified text into lines. If end is specified only the sub-string will be used. +// White space is stripped at the beginning of the rows, the text is split at word boundaries or when new-line characters are encountered. +// Words longer than the max width are slit at nearest character (i.e. no hyphenation). +int nvgTextBreakLines(struct NVGcontext* ctx, const char* string, const char* end, float breakRowWidth, struct NVGtextRow* rows, int maxRows); + +// +// Internal Render API +// +enum NVGtexture { + NVG_TEXTURE_ALPHA = 0x01, + NVG_TEXTURE_RGBA = 0x02, +}; + +struct NVGscissor +{ + float xform[6]; + float extent[2]; +}; + +struct NVGvertex { + float x,y,u,v; +}; + +struct NVGpath { + int first; + int count; + unsigned char closed; + int nbevel; + struct NVGvertex* fill; + int nfill; + struct NVGvertex* stroke; + int nstroke; + int winding; + int convex; +}; + +struct NVGparams { + void* userPtr; + int atlasWidth, atlasHeight; + int edgeAntiAlias; + int (*renderCreate)(void* uptr); + int (*renderCreateTexture)(void* uptr, int type, int w, int h, const unsigned char* data); + int (*renderDeleteTexture)(void* uptr, int image); + int (*renderUpdateTexture)(void* uptr, int image, int x, int y, int w, int h, const unsigned char* data); + int (*renderGetTextureSize)(void* uptr, int image, int* w, int* h); + void (*renderViewport)(void* uptr, int width, int height, int alphaBlend); + void (*renderFlush)(void* uptr, int alphaBlend); + void (*renderFill)(void* uptr, struct NVGpaint* paint, struct NVGscissor* scissor, float fringe, const float* bounds, const struct NVGpath* paths, int npaths); + void (*renderStroke)(void* uptr, struct NVGpaint* paint, struct NVGscissor* scissor, float fringe, float strokeWidth, const struct NVGpath* paths, int npaths); + void (*renderTriangles)(void* uptr, struct NVGpaint* paint, struct NVGscissor* scissor, const struct NVGvertex* verts, int nverts); + void (*renderDelete)(void* uptr); +}; + +// Contructor and destructor, called by the render back-end. +struct NVGcontext* nvgCreateInternal(struct NVGparams* params); +void nvgDeleteInternal(struct NVGcontext* ctx); + +// Debug function to dump cached path data. +void nvgDebugDumpPathCache(struct NVGcontext* ctx); + +#define NVG_NOTUSED(v) do { (void)(1 ? (void)0 : ( (void)(v) ) ); } while(0) + +#ifdef __cplusplus +} +#endif + +#endif // NANOVG_H diff --git a/libs/dgl/src/nanovg/nanovg_gl.h b/libs/dgl/src/nanovg/nanovg_gl.h new file mode 100644 index 0000000..c3c80cf --- /dev/null +++ b/libs/dgl/src/nanovg/nanovg_gl.h @@ -0,0 +1,1293 @@ +// +// Copyright (c) 2009-2013 Mikko Mononen memon@inside.org +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. +// +#ifndef NANOVG_GL3_H +#define NANOVG_GL3_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define NVG_ANTIALIAS 1 + +#if defined NANOVG_GL2_IMPLEMENTATION +# define NANOVG_GL2 1 +# define NANOVG_GL_IMPLEMENTATION 1 +#elif defined NANOVG_GL3_IMPLEMENTATION +# define NANOVG_GL3 1 +# define NANOVG_GL_IMPLEMENTATION 1 +# define NANOVG_GL_USE_UNIFORMBUFFER 1 +#elif defined NANOVG_GLES2_IMPLEMENTATION +# define NANOVG_GLES2 1 +# define NANOVG_GL_IMPLEMENTATION 1 +#elif defined NANOVG_GLES3_IMPLEMENTATION +# define NANOVG_GLES3 1 +# define NANOVG_GL_IMPLEMENTATION 1 +#endif + + +#if defined NANOVG_GL2 + +struct NVGcontext* nvgCreateGL2(int atlasw, int atlash, int edgeaa); +void nvgDeleteGL2(struct NVGcontext* ctx); + +#elif defined NANOVG_GL3 + +struct NVGcontext* nvgCreateGL3(int atlasw, int atlash, int edgeaa); +void nvgDeleteGL3(struct NVGcontext* ctx); + +#elif defined NANOVG_GLES2 + +struct NVGcontext* nvgCreateGLES2(int atlasw, int atlash, int edgeaa); +void nvgDeleteGLES2(struct NVGcontext* ctx); + +#elif defined NANOVG_GLES3 + +struct NVGcontext* nvgCreateGLES3(int atlasw, int atlash, int edgeaa); +void nvgDeleteGLES3(struct NVGcontext* ctx); + +#endif + +#ifdef __cplusplus +} +#endif + +#endif + +#ifdef NANOVG_GL_IMPLEMENTATION + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <math.h> +#include "nanovg.h" + +enum GLNVGuniformLoc { + GLNVG_LOC_VIEWSIZE, + GLNVG_LOC_TEX, +#if NANOVG_GL_USE_UNIFORMBUFFER + GLNVG_LOC_FRAG, +#else + GLNVG_LOC_SCISSORMAT, + GLNVG_LOC_SCISSOREXT, + GLNVG_LOC_SCISSORSCALE, + GLNVG_LOC_PAINTMAT, + GLNVG_LOC_EXTENT, + GLNVG_LOC_RADIUS, + GLNVG_LOC_FEATHER, + GLNVG_LOC_INNERCOL, + GLNVG_LOC_OUTERCOL, + GLNVG_LOC_STROKEMULT, + GLNVG_LOC_TEXTYPE, + GLNVG_LOC_TYPE, +#endif + GLNVG_MAX_LOCS +}; + +enum GLNVGshaderType { + NSVG_SHADER_FILLGRAD, + NSVG_SHADER_FILLIMG, + NSVG_SHADER_SIMPLE, + NSVG_SHADER_IMG +}; + +#if NANOVG_GL_USE_UNIFORMBUFFER +enum GLNVGuniformBindings { + GLNVG_FRAG_BINDING = 0, +}; +#endif + +struct GLNVGshader { + GLuint prog; + GLuint frag; + GLuint vert; + GLint loc[GLNVG_MAX_LOCS]; +}; + +struct GLNVGtexture { + int id; + GLuint tex; + int width, height; + int type; +}; + +enum GLNVGcallType { + GLNVG_NONE = 0, + GLNVG_FILL, + GLNVG_CONVEXFILL, + GLNVG_STROKE, + GLNVG_TRIANGLES, +}; + +struct GLNVGcall { + int type; + int image; + int pathOffset; + int pathCount; + int triangleOffset; + int triangleCount; + int uniformOffset; +}; + +struct GLNVGpath { + int fillOffset; + int fillCount; + int strokeOffset; + int strokeCount; +}; + +struct GLNVGfragUniforms { + float scissorMat[12]; // matrices are actually 3 vec4s + float paintMat[12]; + struct NVGcolor innerCol; + struct NVGcolor outerCol; + float scissorExt[2]; + float scissorScale[2]; + float extent[2]; + float radius; + float feather; + float strokeMult; + int texType; + int type; +}; + +struct GLNVGcontext { + struct GLNVGshader shader; + struct GLNVGtexture* textures; + float view[2]; + int ntextures; + int ctextures; + int textureId; + GLuint vertBuf; +#if defined NANOVG_GL3 + GLuint vertArr; +#endif +#if NANOVG_GL_USE_UNIFORMBUFFER + GLuint fragBuf; +#endif + int fragSize; + int edgeAntiAlias; + + // Per frame buffers + struct GLNVGcall* calls; + int ccalls; + int ncalls; + struct GLNVGpath* paths; + int cpaths; + int npaths; + struct NVGvertex* verts; + int cverts; + int nverts; + unsigned char* uniforms; + int cuniforms; + int nuniforms; +}; + +static int glnvg__maxi(int a, int b) { return a > b ? a : b; } + +static struct GLNVGtexture* glnvg__allocTexture(struct GLNVGcontext* gl) +{ + struct GLNVGtexture* tex = NULL; + int i; + + for (i = 0; i < gl->ntextures; i++) { + if (gl->textures[i].id == 0) { + tex = &gl->textures[i]; + break; + } + } + if (tex == NULL) { + if (gl->ntextures+1 > gl->ctextures) { + struct GLNVGtexture* textures; + int ctextures = glnvg__maxi(gl->ntextures+1, 4) + gl->ctextures/2; // 1.5x Overallocate + textures = (struct GLNVGtexture*)realloc(gl->textures, sizeof(struct GLNVGtexture)*ctextures); + if (textures == NULL) return NULL; + gl->textures = textures; + gl->ctextures = ctextures; + } + tex = &gl->textures[gl->ntextures++]; + } + + memset(tex, 0, sizeof(*tex)); + tex->id = ++gl->textureId; + + return tex; +} + +static struct GLNVGtexture* glnvg__findTexture(struct GLNVGcontext* gl, int id) +{ + int i; + for (i = 0; i < gl->ntextures; i++) + if (gl->textures[i].id == id) + return &gl->textures[i]; + return NULL; +} + +static int glnvg__deleteTexture(struct GLNVGcontext* gl, int id) +{ + int i; + for (i = 0; i < gl->ntextures; i++) { + if (gl->textures[i].id == id) { + if (gl->textures[i].tex != 0) + glDeleteTextures(1, &gl->textures[i].tex); + memset(&gl->textures[i], 0, sizeof(gl->textures[i])); + return 1; + } + } + return 0; +} + +static void glnvg__dumpShaderError(GLuint shader, const char* name, const char* type) +{ + char str[512+1]; + int len = 0; + glGetShaderInfoLog(shader, 512, &len, str); + if (len > 512) len = 512; + str[len] = '\0'; + printf("Shader %s/%s error:\n%s\n", name, type, str); +} + +static void glnvg__dumpProgramError(GLuint prog, const char* name) +{ + char str[512+1]; + int len = 0; + glGetProgramInfoLog(prog, 512, &len, str); + if (len > 512) len = 512; + str[len] = '\0'; + printf("Program %s error:\n%s\n", name, str); +} + +static int glnvg__checkError(const char* str) +{ + GLenum err = glGetError(); + if (err != GL_NO_ERROR) { + printf("Error %08x after %s\n", err, str); + return 1; + } + return 0; +} + +static int glnvg__createShader(struct GLNVGshader* shader, const char* name, const char* header, const char* opts, const char* vshader, const char* fshader) +{ + GLint status; + GLuint prog, vert, frag; + const char* str[3]; + str[0] = header; + str[1] = opts != NULL ? opts : ""; + + memset(shader, 0, sizeof(*shader)); + + prog = glCreateProgram(); + vert = glCreateShader(GL_VERTEX_SHADER); + frag = glCreateShader(GL_FRAGMENT_SHADER); + str[2] = vshader; + glShaderSource(vert, 3, str, 0); + str[2] = fshader; + glShaderSource(frag, 3, str, 0); + + glCompileShader(vert); + glGetShaderiv(vert, GL_COMPILE_STATUS, &status); + if (status != GL_TRUE) { + glnvg__dumpShaderError(vert, name, "vert"); + return 0; + } + + glCompileShader(frag); + glGetShaderiv(frag, GL_COMPILE_STATUS, &status); + if (status != GL_TRUE) { + glnvg__dumpShaderError(frag, name, "frag"); + return 0; + } + + glAttachShader(prog, vert); + glAttachShader(prog, frag); + + glBindAttribLocation(prog, 0, "vertex"); + glBindAttribLocation(prog, 1, "tcoord"); + + glLinkProgram(prog); + glGetProgramiv(prog, GL_LINK_STATUS, &status); + if (status != GL_TRUE) { + glnvg__dumpProgramError(prog, name); + return 0; + } + + shader->prog = prog; + shader->vert = vert; + shader->frag = frag; + + return 1; +} + +static void glnvg__deleteShader(struct GLNVGshader* shader) +{ + if (shader->prog != 0) + glDeleteProgram(shader->prog); + if (shader->vert != 0) + glDeleteShader(shader->vert); + if (shader->frag != 0) + glDeleteShader(shader->frag); +} + +static void glnvg__getUniforms(struct GLNVGshader* shader) +{ + shader->loc[GLNVG_LOC_VIEWSIZE] = glGetUniformLocation(shader->prog, "viewSize"); + shader->loc[GLNVG_LOC_TEX] = glGetUniformLocation(shader->prog, "tex"); + +#if NANOVG_GL_USE_UNIFORMBUFFER + shader->loc[GLNVG_LOC_FRAG] = glGetUniformBlockIndex(shader->prog, "frag"); +#else + shader->loc[GLNVG_LOC_SCISSORMAT] = glGetUniformLocation(shader->prog, "scissorMat"); + shader->loc[GLNVG_LOC_SCISSOREXT] = glGetUniformLocation(shader->prog, "scissorExt"); + shader->loc[GLNVG_LOC_SCISSORSCALE] = glGetUniformLocation(shader->prog, "scissorScale"); + shader->loc[GLNVG_LOC_PAINTMAT] = glGetUniformLocation(shader->prog, "paintMat"); + shader->loc[GLNVG_LOC_EXTENT] = glGetUniformLocation(shader->prog, "extent"); + shader->loc[GLNVG_LOC_RADIUS] = glGetUniformLocation(shader->prog, "radius"); + shader->loc[GLNVG_LOC_FEATHER] = glGetUniformLocation(shader->prog, "feather"); + shader->loc[GLNVG_LOC_INNERCOL] = glGetUniformLocation(shader->prog, "innerCol"); + shader->loc[GLNVG_LOC_OUTERCOL] = glGetUniformLocation(shader->prog, "outerCol"); + shader->loc[GLNVG_LOC_STROKEMULT] = glGetUniformLocation(shader->prog, "strokeMult"); + shader->loc[GLNVG_LOC_TEXTYPE] = glGetUniformLocation(shader->prog, "texType"); + shader->loc[GLNVG_LOC_TYPE] = glGetUniformLocation(shader->prog, "type"); +#endif +} + +static int glnvg__renderCreate(void* uptr) +{ + struct GLNVGcontext* gl = (struct GLNVGcontext*)uptr; + int align = 4; + + // TODO: mediump float may not be enough for GLES2 in iOS. + // see the following discussion: https://github.com/memononen/nanovg/issues/46 + static const char* shaderHeader = +#if defined NANOVG_GL2 + "#define NANOVG_GL2 1\n"; +#elif defined NANOVG_GL3 + "#version 150 core\n" +#if NANOVG_GL_USE_UNIFORMBUFFER + "#define USE_UNIFORMBUFFER 1\n" +#endif + "#define NANOVG_GL3 1\n"; +#elif defined NANOVG_GLES2 + "#version 100\n" + "precision mediump float;\n" + "#define NANOVG_GL2 1\n"; +#elif defined NANOVG_GLES3 + "#version 300 es\n" + "precision mediump float;\n" + "#define NANOVG_GL3 1\n"; +#endif + + static const char* fillVertShader = + "#ifdef NANOVG_GL3\n" + " uniform vec2 viewSize;\n" + " in vec2 vertex;\n" + " in vec2 tcoord;\n" + " out vec2 ftcoord;\n" + " out vec2 fpos;\n" + "#else\n" + " uniform vec2 viewSize;\n" + " attribute vec2 vertex;\n" + " attribute vec2 tcoord;\n" + " varying vec2 ftcoord;\n" + " varying vec2 fpos;\n" + "#endif\n" + "void main(void) {\n" + " ftcoord = tcoord;\n" + " fpos = vertex;\n" + " gl_Position = vec4(2.0*vertex.x/viewSize.x - 1.0, 1.0 - 2.0*vertex.y/viewSize.y, 0, 1);\n" + "}\n"; + + static const char* fillFragShader = + "#ifdef NANOVG_GL3\n" + "#ifdef USE_UNIFORMBUFFER\n" + " layout(std140) uniform frag {\n" + " mat3 scissorMat;\n" + " mat3 paintMat;\n" + " vec4 innerCol;\n" + " vec4 outerCol;\n" + " vec2 scissorExt;\n" + " vec2 scissorScale;\n" + " vec2 extent;\n" + " float radius;\n" + " float feather;\n" + " float strokeMult;\n" + " int texType;\n" + " int type;\n" + " };\n" + "#else\n" + " uniform mat3 scissorMat;\n" + " uniform mat3 paintMat;\n" + " uniform vec4 innerCol;\n" + " uniform vec4 outerCol;\n" + " uniform vec2 scissorExt;\n" + " uniform vec2 scissorScale;\n" + " uniform vec2 extent;\n" + " uniform float radius;\n" + " uniform float feather;\n" + " uniform float strokeMult;\n" + " uniform int texType;\n" + " uniform int type;\n" + "#endif\n" + " uniform sampler2D tex;\n" + " in vec2 ftcoord;\n" + " in vec2 fpos;\n" + " out vec4 outColor;\n" + "#else\n" + " uniform mat3 scissorMat;\n" + " uniform mat3 paintMat;\n" + " uniform vec4 innerCol;\n" + " uniform vec4 outerCol;\n" + " uniform vec2 scissorExt;\n" + " uniform vec2 scissorScale;\n" + " uniform vec2 extent;\n" + " uniform float radius;\n" + " uniform float feather;\n" + " uniform float strokeMult;\n" + " uniform int texType;\n" + " uniform int type;\n" + " uniform sampler2D tex;\n" + " varying vec2 ftcoord;\n" + " varying vec2 fpos;\n" + "#endif\n" + "\n" + "float sdroundrect(vec2 pt, vec2 ext, float rad) {\n" + " vec2 ext2 = ext - vec2(rad,rad);\n" + " vec2 d = abs(pt) - ext2;\n" + " return min(max(d.x,d.y),0.0) + length(max(d,0.0)) - rad;\n" + "}\n" + "\n" + "// Scissoring\n" + "float scissorMask(vec2 p) {\n" + " vec2 sc = (abs((scissorMat * vec3(p,1.0)).xy) - scissorExt);\n" + " sc = vec2(0.5,0.5) - sc * scissorScale;\n" + " return clamp(sc.x,0.0,1.0) * clamp(sc.y,0.0,1.0);\n" + "}\n" + "#ifdef EDGE_AA\n" + "// Stroke - from [0..1] to clipped pyramid, where the slope is 1px.\n" + "float strokeMask() {\n" + " return min(1.0, (1.0-abs(ftcoord.x*2.0-1.0))*strokeMult) * min(1.0, ftcoord.y);\n" + "}\n" + "#endif\n" + "\n" + "void main(void) {\n" + " vec4 result;\n" + " float scissor = scissorMask(fpos);\n" + "#ifdef EDGE_AA\n" + " float strokeAlpha = strokeMask();\n" + "#else\n" + " float strokeAlpha = 1.0;\n" + "#endif\n" + " if (type == 0) { // Gradient\n" + " // Calculate gradient color using box gradient\n" + " vec2 pt = (paintMat * vec3(fpos,1.0)).xy;\n" + " float d = clamp((sdroundrect(pt, extent, radius) + feather*0.5) / feather, 0.0, 1.0);\n" + " vec4 color = mix(innerCol,outerCol,d);\n" + " // Combine alpha\n" + " color.w *= strokeAlpha * scissor;\n" + " result = color;\n" + " } else if (type == 1) { // Image\n" + " // Calculate color fron texture\n" + " vec2 pt = (paintMat * vec3(fpos,1.0)).xy / extent;\n" + "#ifdef NANOVG_GL3\n" + " vec4 color = texture(tex, pt);\n" + "#else\n" + " vec4 color = texture2D(tex, pt);\n" + "#endif\n" + " color = texType == 0 ? color : vec4(1,1,1,color.x);\n" + " // Combine alpha\n" + " color.w *= strokeAlpha * scissor;\n" + " result = color;\n" + " } else if (type == 2) { // Stencil fill\n" + " result = vec4(1,1,1,1);\n" + " } else if (type == 3) { // Textured tris\n" + "#ifdef NANOVG_GL3\n" + " vec4 color = texture(tex, ftcoord);\n" + "#else\n" + " vec4 color = texture2D(tex, ftcoord);\n" + "#endif\n" + " color = texType == 0 ? color : vec4(1,1,1,color.x);\n" + " color.w *= scissor;\n" + " result = color * innerCol;\n" + " }\n" + "#ifdef NANOVG_GL3\n" + " outColor = result;\n" + "#else\n" + " gl_FragColor = result;\n" + "#endif\n" + "}\n"; + + glnvg__checkError("init"); + + if (gl->edgeAntiAlias) { + if (glnvg__createShader(&gl->shader, "shader", shaderHeader, "#define EDGE_AA 1\n", fillVertShader, fillFragShader) == 0) + return 0; + } else { + if (glnvg__createShader(&gl->shader, "shader", shaderHeader, NULL, fillVertShader, fillFragShader) == 0) + return 0; + } + + glnvg__checkError("uniform locations"); + glnvg__getUniforms(&gl->shader); + + // Create dynamic vertex array +#if defined NANOVG_GL3 + glGenVertexArrays(1, &gl->vertArr); +#endif + glGenBuffers(1, &gl->vertBuf); + +#if NANOVG_GL_USE_UNIFORMBUFFER + // Create UBOs + glUniformBlockBinding(gl->shader.prog, gl->shader.loc[GLNVG_LOC_FRAG], GLNVG_FRAG_BINDING); + glGenBuffers(1, &gl->fragBuf); + glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &align); +#endif + gl->fragSize = sizeof(struct GLNVGfragUniforms) + align - sizeof(struct GLNVGfragUniforms) % align; + + glnvg__checkError("create done"); + + glFinish(); + + return 1; +} + +static int glnvg__renderCreateTexture(void* uptr, int type, int w, int h, const unsigned char* data) +{ + struct GLNVGcontext* gl = (struct GLNVGcontext*)uptr; + struct GLNVGtexture* tex = glnvg__allocTexture(gl); + + if (tex == NULL) return 0; + + glGenTextures(1, &tex->tex); + tex->width = w; + tex->height = h; + tex->type = type; + glBindTexture(GL_TEXTURE_2D, tex->tex); + + glPixelStorei(GL_UNPACK_ALIGNMENT,1); +#ifndef NANOVG_GLES2 + glPixelStorei(GL_UNPACK_ROW_LENGTH, tex->width); + glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); + glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); +#endif + + if (type == NVG_TEXTURE_RGBA) + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); + else +#if defined(NANOVG_GLES2) + glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, w, h, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data); +#elif defined(NANOVG_GLES3) + glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, w, h, 0, GL_RED, GL_UNSIGNED_BYTE, data); +#else + glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, w, h, 0, GL_RED, GL_UNSIGNED_BYTE, data); +#endif + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + glPixelStorei(GL_UNPACK_ALIGNMENT, 4); +#ifndef NANOVG_GLES2 + glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); + glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); + glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); +#endif + + if (glnvg__checkError("create tex")) + return 0; + + glBindTexture(GL_TEXTURE_2D, 0); + + return tex->id; +} + + +static int glnvg__renderDeleteTexture(void* uptr, int image) +{ + struct GLNVGcontext* gl = (struct GLNVGcontext*)uptr; + return glnvg__deleteTexture(gl, image); +} + +static int glnvg__renderUpdateTexture(void* uptr, int image, int x, int y, int w, int h, const unsigned char* data) +{ + struct GLNVGcontext* gl = (struct GLNVGcontext*)uptr; + struct GLNVGtexture* tex = glnvg__findTexture(gl, image); + + if (tex == NULL) return 0; + glBindTexture(GL_TEXTURE_2D, tex->tex); + + glPixelStorei(GL_UNPACK_ALIGNMENT,1); + +#ifndef NANOVG_GLES2 + glPixelStorei(GL_UNPACK_ROW_LENGTH, tex->width); + glPixelStorei(GL_UNPACK_SKIP_PIXELS, x); + glPixelStorei(GL_UNPACK_SKIP_ROWS, y); +#else + // No support for all of skip, need to update a whole row at a time. + if (tex->type == NVG_TEXTURE_RGBA) + data += y*tex->width*4; + else + data += y*tex->width; + x = 0; + w = tex->width; +#endif + + if (tex->type == NVG_TEXTURE_RGBA) + glTexSubImage2D(GL_TEXTURE_2D, 0, x,y, w,h, GL_RGBA, GL_UNSIGNED_BYTE, data); + else +#ifdef NANOVG_GLES2 + glTexSubImage2D(GL_TEXTURE_2D, 0, x,y, w,h, GL_LUMINANCE, GL_UNSIGNED_BYTE, data); +#else + glTexSubImage2D(GL_TEXTURE_2D, 0, x,y, w,h, GL_RED, GL_UNSIGNED_BYTE, data); +#endif + + glPixelStorei(GL_UNPACK_ALIGNMENT, 4); +#ifndef NANOVG_GLES2 + glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); + glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); + glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); +#endif + + glBindTexture(GL_TEXTURE_2D, 0); + + return 1; +} + +static int glnvg__renderGetTextureSize(void* uptr, int image, int* w, int* h) +{ + struct GLNVGcontext* gl = (struct GLNVGcontext*)uptr; + struct GLNVGtexture* tex = glnvg__findTexture(gl, image); + if (tex == NULL) return 0; + *w = tex->width; + *h = tex->height; + return 1; +} + +static void glnvg__xformToMat3x4(float* m3, float* t) +{ + m3[0] = t[0]; + m3[1] = t[1]; + m3[2] = 0.0f; + m3[3] = 0.0f; + m3[4] = t[2]; + m3[5] = t[3]; + m3[6] = 0.0f; + m3[7] = 0.0f; + m3[8] = t[4]; + m3[9] = t[5]; + m3[10] = 1.0f; + m3[11] = 0.0f; +} + +static int glnvg__convertPaint(struct GLNVGcontext* gl, struct GLNVGfragUniforms* frag, struct NVGpaint* paint, + struct NVGscissor* scissor, float width, float fringe) +{ + struct GLNVGtexture* tex = NULL; + float invxform[6]; + + memset(frag, 0, sizeof(*frag)); + + frag->innerCol = paint->innerColor; + frag->outerCol = paint->outerColor; + + nvgTransformInverse(invxform, paint->xform); + glnvg__xformToMat3x4(frag->paintMat, invxform); + + if (scissor->extent[0] < 0.5f || scissor->extent[1] < 0.5f) { + memset(frag->scissorMat, 0, sizeof(frag->scissorMat)); + frag->scissorExt[0] = 1.0f; + frag->scissorExt[1] = 1.0f; + frag->scissorScale[0] = 1.0f; + frag->scissorScale[1] = 1.0f; + } else { + nvgTransformInverse(invxform, scissor->xform); + glnvg__xformToMat3x4(frag->scissorMat, invxform); + frag->scissorExt[0] = scissor->extent[0]; + frag->scissorExt[1] = scissor->extent[1]; + frag->scissorScale[0] = sqrtf(scissor->xform[0]*scissor->xform[0] + scissor->xform[2]*scissor->xform[2]) / fringe; + frag->scissorScale[1] = sqrtf(scissor->xform[1]*scissor->xform[1] + scissor->xform[3]*scissor->xform[3]) / fringe; + } + memcpy(frag->extent, paint->extent, sizeof(frag->extent)); + frag->strokeMult = (width*0.5f + fringe*0.5f) / fringe; + + if (paint->image != 0) { + tex = glnvg__findTexture(gl, paint->image); + if (tex == NULL) return 0; + frag->type = NSVG_SHADER_FILLIMG; + frag->texType = tex->type == NVG_TEXTURE_RGBA ? 0 : 1; + } else { + frag->type = NSVG_SHADER_FILLGRAD; + frag->radius = paint->radius; + frag->feather = paint->feather; + } + return 1; +} + +static struct GLNVGfragUniforms* nvg__fragUniformPtr(struct GLNVGcontext* gl, int i); + +#if !NANOVG_GL_USE_UNIFORMBUFFER +static void glnvg__mat3(float* dst, float* src) +{ + dst[0] = src[0]; + dst[1] = src[1]; + dst[2] = src[2]; + + dst[3] = src[4]; + dst[4] = src[5]; + dst[5] = src[6]; + + dst[6] = src[8]; + dst[7] = src[9]; + dst[8] = src[10]; +} +#endif + +static void glnvg__setUniforms(struct GLNVGcontext* gl, int uniformOffset, int image) +{ +#if NANOVG_GL_USE_UNIFORMBUFFER + glBindBufferRange(GL_UNIFORM_BUFFER, GLNVG_FRAG_BINDING, gl->fragBuf, uniformOffset, sizeof(struct GLNVGfragUniforms)); +#else + struct GLNVGfragUniforms* frag = nvg__fragUniformPtr(gl, uniformOffset); + float tmp[9]; // Maybe there's a way to get rid of this... + glnvg__mat3(tmp, frag->scissorMat); + glUniformMatrix3fv(gl->shader.loc[GLNVG_LOC_SCISSORMAT], 1, GL_FALSE, tmp); + glnvg__mat3(tmp, frag->paintMat); + glUniformMatrix3fv(gl->shader.loc[GLNVG_LOC_PAINTMAT], 1, GL_FALSE, tmp); + glUniform4fv(gl->shader.loc[GLNVG_LOC_INNERCOL], 1, frag->innerCol.rgba); + glUniform4fv(gl->shader.loc[GLNVG_LOC_OUTERCOL], 1, frag->outerCol.rgba); + glUniform2fv(gl->shader.loc[GLNVG_LOC_SCISSOREXT], 1, frag->scissorExt); + glUniform2fv(gl->shader.loc[GLNVG_LOC_SCISSORSCALE], 1, frag->scissorScale); + glUniform2fv(gl->shader.loc[GLNVG_LOC_EXTENT], 1, frag->extent); + glUniform1f(gl->shader.loc[GLNVG_LOC_RADIUS], frag->radius); + glUniform1f(gl->shader.loc[GLNVG_LOC_FEATHER], frag->feather); + glUniform1f(gl->shader.loc[GLNVG_LOC_STROKEMULT], frag->strokeMult); + glUniform1i(gl->shader.loc[GLNVG_LOC_TEXTYPE], frag->texType); + glUniform1i(gl->shader.loc[GLNVG_LOC_TYPE], frag->type); +#endif + + if (image != 0) { + struct GLNVGtexture* tex = glnvg__findTexture(gl, image); + glBindTexture(GL_TEXTURE_2D, tex != NULL ? tex->tex : 0); + glnvg__checkError("tex paint tex"); + } else { + glBindTexture(GL_TEXTURE_2D, 0); + } +} + +static void glnvg__renderViewport(void* uptr, int width, int height, int alphaBlend) +{ + struct GLNVGcontext* gl = (struct GLNVGcontext*)uptr; + NVG_NOTUSED(alphaBlend); + gl->view[0] = (float)width; + gl->view[1] = (float)height; +} + +static void glnvg__fill(struct GLNVGcontext* gl, struct GLNVGcall* call) +{ + struct GLNVGpath* paths = &gl->paths[call->pathOffset]; + int i, npaths = call->pathCount; + + // Draw shapes + glEnable(GL_STENCIL_TEST); + glStencilMask(0xff); + glStencilFunc(GL_ALWAYS, 0, ~0L); + glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); + + // set bindpoint for solid loc + glnvg__setUniforms(gl, call->uniformOffset, 0); + glnvg__checkError("fill simple"); + + glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP); + glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_DECR_WRAP); + glDisable(GL_CULL_FACE); + for (i = 0; i < npaths; i++) + glDrawArrays(GL_TRIANGLE_FAN, paths[i].fillOffset, paths[i].fillCount); + glEnable(GL_CULL_FACE); + + // Draw aliased off-pixels + glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + + glnvg__setUniforms(gl, call->uniformOffset + gl->fragSize, call->image); + glnvg__checkError("fill fill"); + + if (gl->edgeAntiAlias) { + glStencilFunc(GL_EQUAL, 0x00, 0xff); + glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); + // Draw fringes + for (i = 0; i < npaths; i++) + glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount); + } + + // Draw fill + glStencilFunc(GL_NOTEQUAL, 0x0, 0xff); + glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO); + glDrawArrays(GL_TRIANGLES, call->triangleOffset, call->triangleCount); + + glDisable(GL_STENCIL_TEST); +} + +static void glnvg__convexFill(struct GLNVGcontext* gl, struct GLNVGcall* call) +{ + struct GLNVGpath* paths = &gl->paths[call->pathOffset]; + int i, npaths = call->pathCount; + + glnvg__setUniforms(gl, call->uniformOffset, call->image); + glnvg__checkError("convex fill"); + + for (i = 0; i < npaths; i++) + glDrawArrays(GL_TRIANGLE_FAN, paths[i].fillOffset, paths[i].fillCount); + if (gl->edgeAntiAlias) { + // Draw fringes + for (i = 0; i < npaths; i++) + glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount); + } +} + +static void glnvg__stroke(struct GLNVGcontext* gl, struct GLNVGcall* call) +{ + struct GLNVGpath* paths = &gl->paths[call->pathOffset]; + int npaths = call->pathCount, i; + + glnvg__setUniforms(gl, call->uniformOffset, call->image); + glnvg__checkError("stroke fill"); + + // Draw Strokes + for (i = 0; i < npaths; i++) + glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount); +} + +static void glnvg__triangles(struct GLNVGcontext* gl, struct GLNVGcall* call) +{ + glnvg__setUniforms(gl, call->uniformOffset, call->image); + glnvg__checkError("triangles fill"); + + glDrawArrays(GL_TRIANGLES, call->triangleOffset, call->triangleCount); +} + +static void glnvg__renderFlush(void* uptr, int alphaBlend) +{ + struct GLNVGcontext* gl = (struct GLNVGcontext*)uptr; + int i; + + if (gl->ncalls > 0) { + + // Setup require GL state. + glUseProgram(gl->shader.prog); + + if (alphaBlend == NVG_PREMULTIPLIED_ALPHA) + glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA); + else + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glEnable(GL_CULL_FACE); + glCullFace(GL_BACK); + glFrontFace(GL_CCW); + glEnable(GL_BLEND); + glDisable(GL_DEPTH_TEST); + glDisable(GL_SCISSOR_TEST); + glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + glStencilMask(0xffffffff); + glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); + glStencilFunc(GL_ALWAYS, 0, 0xffffffff); + glActiveTexture(GL_TEXTURE0); + +#if NANOVG_GL_USE_UNIFORMBUFFER + // Upload ubo for frag shaders + glBindBuffer(GL_UNIFORM_BUFFER, gl->fragBuf); + glBufferData(GL_UNIFORM_BUFFER, gl->nuniforms * gl->fragSize, gl->uniforms, GL_STREAM_DRAW); +#endif + + // Upload vertex data +#if defined NANOVG_GL3 + glBindVertexArray(gl->vertArr); +#endif + glBindBuffer(GL_ARRAY_BUFFER, gl->vertBuf); + glBufferData(GL_ARRAY_BUFFER, gl->nverts * sizeof(struct NVGvertex), gl->verts, GL_STREAM_DRAW); + glEnableVertexAttribArray(0); + glEnableVertexAttribArray(1); + glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(struct NVGvertex), (const GLvoid*)(size_t)0); + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(struct NVGvertex), (const GLvoid*)(0 + 2*sizeof(float))); + + // Set view and texture just once per frame. + glUniform1i(gl->shader.loc[GLNVG_LOC_TEX], 0); + glUniform2fv(gl->shader.loc[GLNVG_LOC_VIEWSIZE], 1, gl->view); + +#if NANOVG_GL_USE_UNIFORMBUFFER + glBindBuffer(GL_UNIFORM_BUFFER, gl->fragBuf); +#endif + + for (i = 0; i < gl->ncalls; i++) { + struct GLNVGcall* call = &gl->calls[i]; + if (call->type == GLNVG_FILL) + glnvg__fill(gl, call); + else if (call->type == GLNVG_CONVEXFILL) + glnvg__convexFill(gl, call); + else if (call->type == GLNVG_STROKE) + glnvg__stroke(gl, call); + else if (call->type == GLNVG_TRIANGLES) + glnvg__triangles(gl, call); + } + + glDisableVertexAttribArray(0); + glDisableVertexAttribArray(1); +#if defined NANOVG_GL3 + glBindVertexArray(0); +#endif + glUseProgram(0); + glBindTexture(GL_TEXTURE_2D, 0); + } + + // Reset calls + gl->nverts = 0; + gl->npaths = 0; + gl->ncalls = 0; + gl->nuniforms = 0; +} + +static int glnvg__maxVertCount(const struct NVGpath* paths, int npaths) +{ + int i, count = 0; + for (i = 0; i < npaths; i++) { + count += paths[i].nfill; + count += paths[i].nstroke; + } + return count; +} + +static struct GLNVGcall* glnvg__allocCall(struct GLNVGcontext* gl) +{ + struct GLNVGcall* ret = NULL; + if (gl->ncalls+1 > gl->ccalls) { + struct GLNVGcall* calls; + int ccalls = glnvg__maxi(gl->ncalls+1, 128) + gl->ccalls; // 1.5x Overallocate + calls = (struct GLNVGcall*)realloc(gl->calls, sizeof(struct GLNVGcall) * ccalls); + if (calls == NULL) return NULL; + gl->calls = calls; + gl->ccalls = ccalls; + } + ret = &gl->calls[gl->ncalls++]; + memset(ret, 0, sizeof(struct GLNVGcall)); + return ret; +} + +static int glnvg__allocPaths(struct GLNVGcontext* gl, int n) +{ + int ret = 0; + if (gl->npaths+n > gl->cpaths) { + struct GLNVGpath* paths; + int cpaths = glnvg__maxi(gl->npaths + n, 128) + gl->cpaths; // 1.5x Overallocate + paths = (struct GLNVGpath*)realloc(gl->paths, sizeof(struct GLNVGpath) * cpaths); + if (paths == NULL) return -1; + gl->paths = paths; + gl->cpaths = cpaths; + } + ret = gl->npaths; + gl->npaths += n; + return ret; +} + +static int glnvg__allocVerts(struct GLNVGcontext* gl, int n) +{ + int ret = 0; + if (gl->nverts+n > gl->cverts) { + struct NVGvertex* verts; + int cverts = glnvg__maxi(gl->nverts + n, 4096) + gl->cverts/2; // 1.5x Overallocate + verts = (struct NVGvertex*)realloc(gl->verts, sizeof(struct NVGvertex) * cverts); + if (verts == NULL) return -1; + gl->verts = verts; + gl->cverts = cverts; + } + ret = gl->nverts; + gl->nverts += n; + return ret; +} + +static int glnvg__allocFragUniforms(struct GLNVGcontext* gl, int n) +{ + int ret = 0, structSize = gl->fragSize; + if (gl->nuniforms+n > gl->cuniforms) { + unsigned char* uniforms; + int cuniforms = glnvg__maxi(gl->nuniforms+n, 128) + gl->cuniforms/2; // 1.5x Overallocate + uniforms = (unsigned char*)realloc(gl->uniforms, structSize * cuniforms); + if (uniforms == NULL) return -1; + gl->uniforms = uniforms; + gl->cuniforms = cuniforms; + } + ret = gl->nuniforms * structSize; + gl->nuniforms += n; + return ret; +} + +static struct GLNVGfragUniforms* nvg__fragUniformPtr(struct GLNVGcontext* gl, int i) +{ + return (struct GLNVGfragUniforms*)&gl->uniforms[i]; +} + +static void glnvg__vset(struct NVGvertex* vtx, float x, float y, float u, float v) +{ + vtx->x = x; + vtx->y = y; + vtx->u = u; + vtx->v = v; +} + +static void glnvg__renderFill(void* uptr, struct NVGpaint* paint, struct NVGscissor* scissor, float fringe, + const float* bounds, const struct NVGpath* paths, int npaths) +{ + struct GLNVGcontext* gl = (struct GLNVGcontext*)uptr; + struct GLNVGcall* call = glnvg__allocCall(gl); + struct NVGvertex* quad; + struct GLNVGfragUniforms* frag; + int i, maxverts, offset; + + if (call == NULL) return; + + call->type = GLNVG_FILL; + call->pathOffset = glnvg__allocPaths(gl, npaths); + if (call->pathOffset == -1) goto error; + call->pathCount = npaths; + call->image = paint->image; + + if (npaths == 1 && paths[0].convex) + call->type = GLNVG_CONVEXFILL; + + // Allocate vertices for all the paths. + maxverts = glnvg__maxVertCount(paths, npaths) + 6; + offset = glnvg__allocVerts(gl, maxverts); + if (offset == -1) goto error; + + for (i = 0; i < npaths; i++) { + struct GLNVGpath* copy = &gl->paths[call->pathOffset + i]; + const struct NVGpath* path = &paths[i]; + memset(copy, 0, sizeof(struct GLNVGpath)); + if (path->nfill > 0) { + copy->fillOffset = offset; + copy->fillCount = path->nfill; + memcpy(&gl->verts[offset], path->fill, sizeof(struct NVGvertex) * path->nfill); + offset += path->nfill; + } + if (path->nstroke > 0) { + copy->strokeOffset = offset; + copy->strokeCount = path->nstroke; + memcpy(&gl->verts[offset], path->stroke, sizeof(struct NVGvertex) * path->nstroke); + offset += path->nstroke; + } + } + + // Quad + call->triangleOffset = offset; + call->triangleCount = 6; + quad = &gl->verts[call->triangleOffset]; + glnvg__vset(&quad[0], bounds[0], bounds[3], 0.5f, 1.0f); + glnvg__vset(&quad[1], bounds[2], bounds[3], 0.5f, 1.0f); + glnvg__vset(&quad[2], bounds[2], bounds[1], 0.5f, 1.0f); + + glnvg__vset(&quad[3], bounds[0], bounds[3], 0.5f, 1.0f); + glnvg__vset(&quad[4], bounds[2], bounds[1], 0.5f, 1.0f); + glnvg__vset(&quad[5], bounds[0], bounds[1], 0.5f, 1.0f); + + // Setup uniforms for draw calls + if (call->type == GLNVG_FILL) { + call->uniformOffset = glnvg__allocFragUniforms(gl, 2); + if (call->uniformOffset == -1) goto error; + // Simple shader for stencil + frag = nvg__fragUniformPtr(gl, call->uniformOffset); + memset(frag, 0, sizeof(*frag)); + frag->type = NSVG_SHADER_SIMPLE; + // Fill shader + glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset + gl->fragSize), paint, scissor, fringe, fringe); + } else { + call->uniformOffset = glnvg__allocFragUniforms(gl, 1); + if (call->uniformOffset == -1) goto error; + // Fill shader + glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset), paint, scissor, fringe, fringe); + } + + return; + +error: + // We get here if call alloc was ok, but something else is not. + // Roll back the last call to prevent drawing it. + if (gl->ncalls > 0) gl->ncalls--; +} + +static void glnvg__renderStroke(void* uptr, struct NVGpaint* paint, struct NVGscissor* scissor, float fringe, + float strokeWidth, const struct NVGpath* paths, int npaths) +{ + struct GLNVGcontext* gl = (struct GLNVGcontext*)uptr; + struct GLNVGcall* call = glnvg__allocCall(gl); + int i, maxverts, offset; + + if (call == NULL) return; + + call->type = GLNVG_STROKE; + call->pathOffset = glnvg__allocPaths(gl, npaths); + if (call->pathOffset == -1) goto error; + call->pathCount = npaths; + call->image = paint->image; + + // Allocate vertices for all the paths. + maxverts = glnvg__maxVertCount(paths, npaths); + offset = glnvg__allocVerts(gl, maxverts); + if (offset == -1) goto error; + + for (i = 0; i < npaths; i++) { + struct GLNVGpath* copy = &gl->paths[call->pathOffset + i]; + const struct NVGpath* path = &paths[i]; + memset(copy, 0, sizeof(struct GLNVGpath)); + if (path->nstroke) { + copy->strokeOffset = offset; + copy->strokeCount = path->nstroke; + memcpy(&gl->verts[offset], path->stroke, sizeof(struct NVGvertex) * path->nstroke); + offset += path->nstroke; + } + } + + // Fill shader + call->uniformOffset = glnvg__allocFragUniforms(gl, 1); + if (call->uniformOffset == -1) goto error; + glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset), paint, scissor, strokeWidth, fringe); + + return; + +error: + // We get here if call alloc was ok, but something else is not. + // Roll back the last call to prevent drawing it. + if (gl->ncalls > 0) gl->ncalls--; +} + +static void glnvg__renderTriangles(void* uptr, struct NVGpaint* paint, struct NVGscissor* scissor, + const struct NVGvertex* verts, int nverts) +{ + struct GLNVGcontext* gl = (struct GLNVGcontext*)uptr; + struct GLNVGcall* call = glnvg__allocCall(gl); + struct GLNVGfragUniforms* frag; + + if (call == NULL) return; + + call->type = GLNVG_TRIANGLES; + call->image = paint->image; + + // Allocate vertices for all the paths. + call->triangleOffset = glnvg__allocVerts(gl, nverts); + if (call->triangleOffset == -1) goto error; + call->triangleCount = nverts; + + memcpy(&gl->verts[call->triangleOffset], verts, sizeof(struct NVGvertex) * nverts); + + // Fill shader + call->uniformOffset = glnvg__allocFragUniforms(gl, 1); + if (call->uniformOffset == -1) goto error; + frag = nvg__fragUniformPtr(gl, call->uniformOffset); + glnvg__convertPaint(gl, frag, paint, scissor, 1.0f, 1.0f); + frag->type = NSVG_SHADER_IMG; + + return; + +error: + // We get here if call alloc was ok, but something else is not. + // Roll back the last call to prevent drawing it. + if (gl->ncalls > 0) gl->ncalls--; +} + +static void glnvg__renderDelete(void* uptr) +{ + struct GLNVGcontext* gl = (struct GLNVGcontext*)uptr; + int i; + if (gl == NULL) return; + + glnvg__deleteShader(&gl->shader); + +#if NANOVG_GL3 +#if NANOVG_GL_USE_UNIFORMBUFFER + if (gl->fragBuf != 0) + glDeleteBuffers(1, &gl->fragBuf); +#endif + if (gl->vertArr != 0) + glDeleteVertexArrays(1, &gl->vertArr); +#endif + if (gl->vertBuf != 0) + glDeleteBuffers(1, &gl->vertBuf); + + for (i = 0; i < gl->ntextures; i++) { + if (gl->textures[i].tex != 0) + glDeleteTextures(1, &gl->textures[i].tex); + } + free(gl->textures); + + free(gl); +} + + +#if defined NANOVG_GL2 +struct NVGcontext* nvgCreateGL2(int atlasw, int atlash, int edgeaa) +#elif defined NANOVG_GL3 +struct NVGcontext* nvgCreateGL3(int atlasw, int atlash, int edgeaa) +#elif defined NANOVG_GLES2 +struct NVGcontext* nvgCreateGLES2(int atlasw, int atlash, int edgeaa) +#elif defined NANOVG_GLES3 +struct NVGcontext* nvgCreateGLES3(int atlasw, int atlash, int edgeaa) +#endif +{ + struct NVGparams params; + struct NVGcontext* ctx = NULL; + struct GLNVGcontext* gl = (struct GLNVGcontext*)malloc(sizeof(struct GLNVGcontext)); + if (gl == NULL) goto error; + memset(gl, 0, sizeof(struct GLNVGcontext)); + + memset(¶ms, 0, sizeof(params)); + params.renderCreate = glnvg__renderCreate; + params.renderCreateTexture = glnvg__renderCreateTexture; + params.renderDeleteTexture = glnvg__renderDeleteTexture; + params.renderUpdateTexture = glnvg__renderUpdateTexture; + params.renderGetTextureSize = glnvg__renderGetTextureSize; + params.renderViewport = glnvg__renderViewport; + params.renderFlush = glnvg__renderFlush; + params.renderFill = glnvg__renderFill; + params.renderStroke = glnvg__renderStroke; + params.renderTriangles = glnvg__renderTriangles; + params.renderDelete = glnvg__renderDelete; + params.userPtr = gl; + params.atlasWidth = atlasw; + params.atlasHeight = atlash; + params.edgeAntiAlias = edgeaa; + + gl->edgeAntiAlias = edgeaa; + + ctx = nvgCreateInternal(¶ms); + if (ctx == NULL) goto error; + + return ctx; + +error: + // 'gl' is freed by nvgDeleteInternal. + if (ctx != NULL) nvgDeleteInternal(ctx); + return NULL; +} + +#if NANOVG_GL2 +void nvgDeleteGL2(struct NVGcontext* ctx) +#elif NANOVG_GL3 +void nvgDeleteGL3(struct NVGcontext* ctx) +#elif NANOVG_GLES2 +void nvgDeleteGLES2(struct NVGcontext* ctx) +#elif NANOVG_GLES3 +void nvgDeleteGLES3(struct NVGcontext* ctx) +#endif +{ + nvgDeleteInternal(ctx); +} + +#endif diff --git a/libs/dgl/src/nanovg/stb_image.c b/libs/dgl/src/nanovg/stb_image.c new file mode 100644 index 0000000..1ec363b --- /dev/null +++ b/libs/dgl/src/nanovg/stb_image.c @@ -0,0 +1,4676 @@ +/* stbi-1.33 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c
+ when you control the images you're loading
+ no warranty implied; use at your own risk
+
+ QUICK NOTES:
+ Primarily of interest to game developers and other people who can
+ avoid problematic images and only need the trivial interface
+
+ JPEG baseline (no JPEG progressive)
+ PNG 8-bit-per-channel only
+
+ TGA (not sure what subset, if a subset)
+ BMP non-1bpp, non-RLE
+ PSD (composited view only, no extra channels)
+
+ GIF (*comp always reports as 4-channel)
+ HDR (radiance rgbE format)
+ PIC (Softimage PIC)
+
+ - decode from memory or through FILE (define STBI_NO_STDIO to remove code)
+ - decode from arbitrary I/O callbacks
+ - overridable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD)
+
+ Latest revisions:
+ 1.33 (2011-07-14) minor fixes suggested by Dave Moore
+ 1.32 (2011-07-13) info support for all filetypes (SpartanJ)
+ 1.31 (2011-06-19) a few more leak fixes, bug in PNG handling (SpartanJ)
+ 1.30 (2011-06-11) added ability to load files via io callbacks (Ben Wenger)
+ 1.29 (2010-08-16) various warning fixes from Aurelien Pocheville
+ 1.28 (2010-08-01) fix bug in GIF palette transparency (SpartanJ)
+ 1.27 (2010-08-01) cast-to-uint8 to fix warnings (Laurent Gomila)
+ allow trailing 0s at end of image data (Laurent Gomila)
+ 1.26 (2010-07-24) fix bug in file buffering for PNG reported by SpartanJ
+
+ See end of file for full revision history.
+
+ TODO:
+ stbi_info support for BMP,PSD,HDR,PIC
+
+
+ ============================ Contributors =========================
+
+ Image formats Optimizations & bugfixes
+ Sean Barrett (jpeg, png, bmp) Fabian "ryg" Giesen
+ Nicolas Schulz (hdr, psd)
+ Jonathan Dummer (tga) Bug fixes & warning fixes
+ Jean-Marc Lienher (gif) Marc LeBlanc
+ Tom Seddon (pic) Christpher Lloyd
+ Thatcher Ulrich (psd) Dave Moore
+ Won Chun
+ the Horde3D community
+ Extensions, features Janez Zemva
+ Jetro Lauha (stbi_info) Jonathan Blow
+ James "moose2000" Brown (iPhone PNG) Laurent Gomila
+ Ben "Disch" Wenger (io callbacks) Aruelien Pocheville
+ Martin "SpartanJ" Golini Ryamond Barbiero
+ David Woo
+
+
+ If your name should be here but isn't, let Sean know.
+
+*/
+
+#ifndef STBI_INCLUDE_STB_IMAGE_H
+#define STBI_INCLUDE_STB_IMAGE_H
+
+// To get a header file for this, either cut and paste the header,
+// or create stb_image.h, #define STBI_HEADER_FILE_ONLY, and
+// then include stb_image.c from it.
+
+//// begin header file ////////////////////////////////////////////////////
+//
+// Limitations:
+// - no jpeg progressive support
+// - non-HDR formats support 8-bit samples only (jpeg, png)
+// - no delayed line count (jpeg) -- IJG doesn't support either
+// - no 1-bit BMP
+// - GIF always returns *comp=4
+//
+// Basic usage (see HDR discussion below):
+// int x,y,n;
+// unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
+// // ... process data if not NULL ...
+// // ... x = width, y = height, n = # 8-bit components per pixel ...
+// // ... replace '0' with '1'..'4' to force that many components per pixel
+// // ... but 'n' will always be the number that it would have been if you said 0
+// stbi_image_free(data)
+//
+// Standard parameters:
+// int *x -- outputs image width in pixels
+// int *y -- outputs image height in pixels
+// int *comp -- outputs # of image components in image file
+// int req_comp -- if non-zero, # of image components requested in result
+//
+// The return value from an image loader is an 'unsigned char *' which points
+// to the pixel data. The pixel data consists of *y scanlines of *x pixels,
+// with each pixel consisting of N interleaved 8-bit components; the first
+// pixel pointed to is top-left-most in the image. There is no padding between
+// image scanlines or between pixels, regardless of format. The number of
+// components N is 'req_comp' if req_comp is non-zero, or *comp otherwise.
+// If req_comp is non-zero, *comp has the number of components that _would_
+// have been output otherwise. E.g. if you set req_comp to 4, you will always
+// get RGBA output, but you can check *comp to easily see if it's opaque.
+//
+// An output image with N components has the following components interleaved
+// in this order in each pixel:
+//
+// N=#comp components
+// 1 grey
+// 2 grey, alpha
+// 3 red, green, blue
+// 4 red, green, blue, alpha
+//
+// If image loading fails for any reason, the return value will be NULL,
+// and *x, *y, *comp will be unchanged. The function stbi_failure_reason()
+// can be queried for an extremely brief, end-user unfriendly explanation
+// of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid
+// compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
+// more user-friendly ones.
+//
+// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
+//
+// ===========================================================================
+//
+// iPhone PNG support:
+//
+// By default we convert iphone-formatted PNGs back to RGB; nominally they
+// would silently load as BGR, except the existing code should have just
+// failed on such iPhone PNGs. But you can disable this conversion by
+// by calling stbi_convert_iphone_png_to_rgb(0), in which case
+// you will always just get the native iphone "format" through.
+//
+// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
+// pixel to remove any premultiplied alpha *only* if the image file explicitly
+// says there's premultiplied data (currently only happens in iPhone images,
+// and only if iPhone convert-to-rgb processing is on).
+//
+// ===========================================================================
+//
+// HDR image support (disable by defining STBI_NO_HDR)
+//
+// stb_image now supports loading HDR images in general, and currently
+// the Radiance .HDR file format, although the support is provided
+// generically. You can still load any file through the existing interface;
+// if you attempt to load an HDR file, it will be automatically remapped to
+// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
+// both of these constants can be reconfigured through this interface:
+//
+// stbi_hdr_to_ldr_gamma(2.2f);
+// stbi_hdr_to_ldr_scale(1.0f);
+//
+// (note, do not use _inverse_ constants; stbi_image will invert them
+// appropriately).
+//
+// Additionally, there is a new, parallel interface for loading files as
+// (linear) floats to preserve the full dynamic range:
+//
+// float *data = stbi_loadf(filename, &x, &y, &n, 0);
+//
+// If you load LDR images through this interface, those images will
+// be promoted to floating point values, run through the inverse of
+// constants corresponding to the above:
+//
+// stbi_ldr_to_hdr_scale(1.0f);
+// stbi_ldr_to_hdr_gamma(2.2f);
+//
+// Finally, given a filename (or an open file or memory block--see header
+// file for details) containing image data, you can query for the "most
+// appropriate" interface to use (that is, whether the image is HDR or
+// not), using:
+//
+// stbi_is_hdr(char *filename);
+//
+// ===========================================================================
+//
+// I/O callbacks
+//
+// I/O callbacks allow you to read from arbitrary sources, like packaged
+// files or some other source. Data read from callbacks are processed
+// through a small internal buffer (currently 128 bytes) to try to reduce
+// overhead.
+//
+// The three functions you must define are "read" (reads some bytes of data),
+// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
+
+
+#ifndef STBI_NO_STDIO
+
+#if defined(_MSC_VER) && _MSC_VER >= 0x1400
+#define _CRT_SECURE_NO_WARNINGS // suppress bogus warnings about fopen()
+#endif
+
+#include <stdio.h>
+#endif
+
+#define STBI_VERSION 1
+
+enum
+{
+ STBI_default = 0, // only used for req_comp
+
+ STBI_grey = 1,
+ STBI_grey_alpha = 2,
+ STBI_rgb = 3,
+ STBI_rgb_alpha = 4
+};
+
+typedef unsigned char stbi_uc;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PRIMARY API - works on images of any type
+//
+
+//
+// load image by filename, open file, or memory buffer
+//
+
+extern stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+
+#ifndef STBI_NO_STDIO
+extern stbi_uc *stbi_load (char const *filename, int *x, int *y, int *comp, int req_comp);
+extern stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
+// for stbi_load_from_file, file pointer is left pointing immediately after image
+#endif
+
+typedef struct
+{
+ int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read
+ void (*skip) (void *user,unsigned n); // skip the next 'n' bytes
+ int (*eof) (void *user); // returns nonzero if we are at end of file/data
+} stbi_io_callbacks;
+
+extern stbi_uc *stbi_load_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
+
+#ifndef STBI_NO_HDR
+ extern float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+
+ #ifndef STBI_NO_STDIO
+ extern float *stbi_loadf (char const *filename, int *x, int *y, int *comp, int req_comp);
+ extern float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
+ #endif
+
+ extern float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
+
+ extern void stbi_hdr_to_ldr_gamma(float gamma);
+ extern void stbi_hdr_to_ldr_scale(float scale);
+
+ extern void stbi_ldr_to_hdr_gamma(float gamma);
+ extern void stbi_ldr_to_hdr_scale(float scale);
+#endif // STBI_NO_HDR
+
+// stbi_is_hdr is always defined
+extern int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+extern int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
+#ifndef STBI_NO_STDIO
+extern int stbi_is_hdr (char const *filename);
+extern int stbi_is_hdr_from_file(FILE *f);
+#endif // STBI_NO_STDIO
+
+
+// get a VERY brief reason for failure
+// NOT THREADSAFE
+extern const char *stbi_failure_reason (void);
+
+// free the loaded image -- this is just free()
+extern void stbi_image_free (void *retval_from_stbi_load);
+
+// get image dimensions & components without fully decoding
+extern int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
+extern int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
+
+#ifndef STBI_NO_STDIO
+extern int stbi_info (char const *filename, int *x, int *y, int *comp);
+extern int stbi_info_from_file (FILE *f, int *x, int *y, int *comp);
+
+#endif
+
+
+
+// for image formats that explicitly notate that they have premultiplied alpha,
+// we just return the colors as stored in the file. set this flag to force
+// unpremultiplication. results are undefined if the unpremultiply overflow.
+extern void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
+
+// indicate whether we should process iphone images back to canonical format,
+// or just pass them through "as-is"
+extern void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
+
+
+// ZLIB client - used by PNG, available for other purposes
+
+extern char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
+extern char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
+extern int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+extern char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
+extern int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+
+// define faster low-level operations (typically SIMD support)
+#ifdef STBI_SIMD
+typedef void (*stbi_idct_8x8)(stbi_uc *out, int out_stride, short data[64], unsigned short *dequantize);
+// compute an integer IDCT on "input"
+// input[x] = data[x] * dequantize[x]
+// write results to 'out': 64 samples, each run of 8 spaced by 'out_stride'
+// CLAMP results to 0..255
+typedef void (*stbi_YCbCr_to_RGB_run)(stbi_uc *output, stbi_uc const *y, stbi_uc const *cb, stbi_uc const *cr, int count, int step);
+// compute a conversion from YCbCr to RGB
+// 'count' pixels
+// write pixels to 'output'; each pixel is 'step' bytes (either 3 or 4; if 4, write '255' as 4th), order R,G,B
+// y: Y input channel
+// cb: Cb input channel; scale/biased to be 0..255
+// cr: Cr input channel; scale/biased to be 0..255
+
+extern void stbi_install_idct(stbi_idct_8x8 func);
+extern void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func);
+#endif // STBI_SIMD
+
+
+#ifdef __cplusplus
+}
+#endif
+
+//
+//
+//// end header file /////////////////////////////////////////////////////
+#endif // STBI_INCLUDE_STB_IMAGE_H
+
+#ifndef STBI_HEADER_FILE_ONLY
+
+#ifndef STBI_NO_HDR
+#include <math.h> // ldexp
+#include <string.h> // strcmp, strtok
+#endif
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif
+#include <stdlib.h>
+#include <memory.h>
+#include <assert.h>
+#include <stdarg.h>
+
+#ifndef _MSC_VER
+ #ifdef __cplusplus
+ #define stbi_inline inline
+ #else
+ #define stbi_inline
+ #endif
+#else
+ #define stbi_inline __forceinline
+#endif
+
+
+// implementation:
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef signed short int16;
+typedef unsigned int uint32;
+typedef signed int int32;
+typedef unsigned int uint;
+
+// should produce compiler error if size is wrong
+typedef unsigned char validate_uint32[sizeof(uint32)==4 ? 1 : -1];
+
+#if defined(STBI_NO_STDIO) && !defined(STBI_NO_WRITE)
+#define STBI_NO_WRITE
+#endif
+
+#define STBI_NOTUSED(v) (void)sizeof(v)
+
+#ifdef _MSC_VER
+#define STBI_HAS_LROTL
+#endif
+
+#ifdef STBI_HAS_LROTL
+ #define stbi_lrot(x,y) _lrotl(x,y)
+#else
+ #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y))))
+#endif
+
+///////////////////////////////////////////////
+//
+// stbi struct and start_xxx functions
+
+// stbi structure is our basic context used by all images, so it
+// contains all the IO context, plus some basic image information
+typedef struct
+{
+ uint32 img_x, img_y;
+ int img_n, img_out_n;
+
+ stbi_io_callbacks io;
+ void *io_user_data;
+
+ int read_from_callbacks;
+ int buflen;
+ uint8 buffer_start[128];
+
+ uint8 *img_buffer, *img_buffer_end;
+ uint8 *img_buffer_original;
+} stbi;
+
+
+static void refill_buffer(stbi *s);
+
+// initialize a memory-decode context
+static void start_mem(stbi *s, uint8 const *buffer, int len)
+{
+ s->io.read = NULL;
+ s->read_from_callbacks = 0;
+ s->img_buffer = s->img_buffer_original = (uint8 *) buffer;
+ s->img_buffer_end = (uint8 *) buffer+len;
+}
+
+// initialize a callback-based context
+static void start_callbacks(stbi *s, stbi_io_callbacks *c, void *user)
+{
+ s->io = *c;
+ s->io_user_data = user;
+ s->buflen = sizeof(s->buffer_start);
+ s->read_from_callbacks = 1;
+ s->img_buffer_original = s->buffer_start;
+ refill_buffer(s);
+}
+
+#ifndef STBI_NO_STDIO
+
+static int stdio_read(void *user, char *data, int size)
+{
+ return (int) fread(data,1,size,(FILE*) user);
+}
+
+static void stdio_skip(void *user, unsigned n)
+{
+ fseek((FILE*) user, n, SEEK_CUR);
+}
+
+static int stdio_eof(void *user)
+{
+ return feof((FILE*) user);
+}
+
+static stbi_io_callbacks stbi_stdio_callbacks =
+{
+ stdio_read,
+ stdio_skip,
+ stdio_eof,
+};
+
+static void start_file(stbi *s, FILE *f)
+{
+ start_callbacks(s, &stbi_stdio_callbacks, (void *) f);
+}
+
+//static void stop_file(stbi *s) { }
+
+#endif // !STBI_NO_STDIO
+
+static void stbi_rewind(stbi *s)
+{
+ // conceptually rewind SHOULD rewind to the beginning of the stream,
+ // but we just rewind to the beginning of the initial buffer, because
+ // we only use it after doing 'test', which only ever looks at at most 92 bytes
+ s->img_buffer = s->img_buffer_original;
+}
+
+static int stbi_jpeg_test(stbi *s);
+static stbi_uc *stbi_jpeg_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int stbi_jpeg_info(stbi *s, int *x, int *y, int *comp);
+static int stbi_png_test(stbi *s);
+static stbi_uc *stbi_png_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int stbi_png_info(stbi *s, int *x, int *y, int *comp);
+static int stbi_bmp_test(stbi *s);
+static stbi_uc *stbi_bmp_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int stbi_tga_test(stbi *s);
+static stbi_uc *stbi_tga_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int stbi_tga_info(stbi *s, int *x, int *y, int *comp);
+static int stbi_psd_test(stbi *s);
+static stbi_uc *stbi_psd_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int stbi_hdr_test(stbi *s);
+static float *stbi_hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int stbi_pic_test(stbi *s);
+static stbi_uc *stbi_pic_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int stbi_gif_test(stbi *s);
+static stbi_uc *stbi_gif_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int stbi_gif_info(stbi *s, int *x, int *y, int *comp);
+
+
+// this is not threadsafe
+static const char *failure_reason;
+
+const char *stbi_failure_reason(void)
+{
+ return failure_reason;
+}
+
+static int e(const char *str)
+{
+ failure_reason = str;
+ return 0;
+}
+
+// e - error
+// epf - error returning pointer to float
+// epuc - error returning pointer to unsigned char
+
+#ifdef STBI_NO_FAILURE_STRINGS
+ #define e(x,y) 0
+#elif defined(STBI_FAILURE_USERMSG)
+ #define e(x,y) e(y)
+#else
+ #define e(x,y) e(x)
+#endif
+
+#define epf(x,y) ((float *) (e(x,y)?NULL:NULL))
+#define epuc(x,y) ((unsigned char *) (e(x,y)?NULL:NULL))
+
+void stbi_image_free(void *retval_from_stbi_load)
+{
+ free(retval_from_stbi_load);
+}
+
+#ifndef STBI_NO_HDR
+static float *ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
+static stbi_uc *hdr_to_ldr(float *data, int x, int y, int comp);
+#endif
+
+static unsigned char *stbi_load_main(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+ if (stbi_jpeg_test(s)) return stbi_jpeg_load(s,x,y,comp,req_comp);
+ if (stbi_png_test(s)) return stbi_png_load(s,x,y,comp,req_comp);
+ if (stbi_bmp_test(s)) return stbi_bmp_load(s,x,y,comp,req_comp);
+ if (stbi_gif_test(s)) return stbi_gif_load(s,x,y,comp,req_comp);
+ if (stbi_psd_test(s)) return stbi_psd_load(s,x,y,comp,req_comp);
+ if (stbi_pic_test(s)) return stbi_pic_load(s,x,y,comp,req_comp);
+
+ #ifndef STBI_NO_HDR
+ if (stbi_hdr_test(s)) {
+ float *hdr = stbi_hdr_load(s, x,y,comp,req_comp);
+ return hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
+ }
+ #endif
+
+ // test tga last because it's a crappy test!
+ if (stbi_tga_test(s))
+ return stbi_tga_load(s,x,y,comp,req_comp);
+ return epuc("unknown image type", "Image not of any known type, or corrupt");
+}
+
+#ifndef STBI_NO_STDIO
+unsigned char *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+ FILE *f = fopen(filename, "rb");
+ unsigned char *result;
+ if (!f) return epuc("can't fopen", "Unable to open file");
+ result = stbi_load_from_file(f,x,y,comp,req_comp);
+ fclose(f);
+ return result;
+}
+
+unsigned char *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+ stbi s;
+ start_file(&s,f);
+ return stbi_load_main(&s,x,y,comp,req_comp);
+}
+#endif //!STBI_NO_STDIO
+
+unsigned char *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+ stbi s;
+ start_mem(&s,buffer,len);
+ return stbi_load_main(&s,x,y,comp,req_comp);
+}
+
+unsigned char *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+ stbi s;
+ start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+ return stbi_load_main(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_HDR
+
+float *stbi_loadf_main(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+ unsigned char *data;
+ #ifndef STBI_NO_HDR
+ if (stbi_hdr_test(s))
+ return stbi_hdr_load(s,x,y,comp,req_comp);
+ #endif
+ data = stbi_load_main(s, x, y, comp, req_comp);
+ if (data)
+ return ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
+ return epf("unknown image type", "Image not of any known type, or corrupt");
+}
+
+float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+ stbi s;
+ start_mem(&s,buffer,len);
+ return stbi_loadf_main(&s,x,y,comp,req_comp);
+}
+
+float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+ stbi s;
+ start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+ return stbi_loadf_main(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_STDIO
+float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+ FILE *f = fopen(filename, "rb");
+ float *result;
+ if (!f) return epf("can't fopen", "Unable to open file");
+ result = stbi_loadf_from_file(f,x,y,comp,req_comp);
+ fclose(f);
+ return result;
+}
+
+float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+ stbi s;
+ start_file(&s,f);
+ return stbi_loadf_main(&s,x,y,comp,req_comp);
+}
+#endif // !STBI_NO_STDIO
+
+#endif // !STBI_NO_HDR
+
+// these is-hdr-or-not is defined independent of whether STBI_NO_HDR is
+// defined, for API simplicity; if STBI_NO_HDR is defined, it always
+// reports false!
+
+int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
+{
+ #ifndef STBI_NO_HDR
+ stbi s;
+ start_mem(&s,buffer,len);
+ return stbi_hdr_test(&s);
+ #else
+ STBI_NOTUSED(buffer);
+ STBI_NOTUSED(len);
+ return 0;
+ #endif
+}
+
+#ifndef STBI_NO_STDIO
+extern int stbi_is_hdr (char const *filename)
+{
+ FILE *f = fopen(filename, "rb");
+ int result=0;
+ if (f) {
+ result = stbi_is_hdr_from_file(f);
+ fclose(f);
+ }
+ return result;
+}
+
+extern int stbi_is_hdr_from_file(FILE *f)
+{
+ #ifndef STBI_NO_HDR
+ stbi s;
+ start_file(&s,f);
+ return stbi_hdr_test(&s);
+ #else
+ return 0;
+ #endif
+}
+#endif // !STBI_NO_STDIO
+
+extern int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
+{
+ #ifndef STBI_NO_HDR
+ stbi s;
+ start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+ return stbi_hdr_test(&s);
+ #else
+ return 0;
+ #endif
+}
+
+#ifndef STBI_NO_HDR
+static float h2l_gamma_i=1.0f/2.2f, h2l_scale_i=1.0f;
+static float l2h_gamma=2.2f, l2h_scale=1.0f;
+
+void stbi_hdr_to_ldr_gamma(float gamma) { h2l_gamma_i = 1/gamma; }
+void stbi_hdr_to_ldr_scale(float scale) { h2l_scale_i = 1/scale; }
+
+void stbi_ldr_to_hdr_gamma(float gamma) { l2h_gamma = gamma; }
+void stbi_ldr_to_hdr_scale(float scale) { l2h_scale = scale; }
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Common code used by all image loaders
+//
+
+enum
+{
+ SCAN_load=0,
+ SCAN_type,
+ SCAN_header
+};
+
+static void refill_buffer(stbi *s)
+{
+ int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
+ if (n == 0) {
+ // at end of file, treat same as if from memory
+ s->read_from_callbacks = 0;
+ s->img_buffer = s->img_buffer_end-1;
+ *s->img_buffer = 0;
+ } else {
+ s->img_buffer = s->buffer_start;
+ s->img_buffer_end = s->buffer_start + n;
+ }
+}
+
+stbi_inline static int get8(stbi *s)
+{
+ if (s->img_buffer < s->img_buffer_end)
+ return *s->img_buffer++;
+ if (s->read_from_callbacks) {
+ refill_buffer(s);
+ return *s->img_buffer++;
+ }
+ return 0;
+}
+
+stbi_inline static int at_eof(stbi *s)
+{
+ if (s->io.read) {
+ if (!(s->io.eof)(s->io_user_data)) return 0;
+ // if feof() is true, check if buffer = end
+ // special case: we've only got the special 0 character at the end
+ if (s->read_from_callbacks == 0) return 1;
+ }
+
+ return s->img_buffer >= s->img_buffer_end;
+}
+
+stbi_inline static uint8 get8u(stbi *s)
+{
+ return (uint8) get8(s);
+}
+
+static void skip(stbi *s, int n)
+{
+ if (s->io.read) {
+ int blen = s->img_buffer_end - s->img_buffer;
+ if (blen < n) {
+ s->img_buffer = s->img_buffer_end;
+ (s->io.skip)(s->io_user_data, n - blen);
+ return;
+ }
+ }
+ s->img_buffer += n;
+}
+
+static int getn(stbi *s, stbi_uc *buffer, int n)
+{
+ if (s->io.read) {
+ int blen = s->img_buffer_end - s->img_buffer;
+ if (blen < n) {
+ int res, count;
+
+ memcpy(buffer, s->img_buffer, blen);
+
+ count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
+ res = (count == (n-blen));
+ s->img_buffer = s->img_buffer_end;
+ return res;
+ }
+ }
+
+ if (s->img_buffer+n <= s->img_buffer_end) {
+ memcpy(buffer, s->img_buffer, n);
+ s->img_buffer += n;
+ return 1;
+ } else
+ return 0;
+}
+
+static int get16(stbi *s)
+{
+ int z = get8(s);
+ return (z << 8) + get8(s);
+}
+
+static uint32 get32(stbi *s)
+{
+ uint32 z = get16(s);
+ return (z << 16) + get16(s);
+}
+
+static int get16le(stbi *s)
+{
+ int z = get8(s);
+ return z + (get8(s) << 8);
+}
+
+static uint32 get32le(stbi *s)
+{
+ uint32 z = get16le(s);
+ return z + (get16le(s) << 16);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// generic converter from built-in img_n to req_comp
+// individual types do this automatically as much as possible (e.g. jpeg
+// does all cases internally since it needs to colorspace convert anyway,
+// and it never has alpha, so very few cases ). png can automatically
+// interleave an alpha=255 channel, but falls back to this for other cases
+//
+// assume data buffer is malloced, so malloc a new one and free that one
+// only failure mode is malloc failing
+
+static uint8 compute_y(int r, int g, int b)
+{
+ return (uint8) (((r*77) + (g*150) + (29*b)) >> 8);
+}
+
+static unsigned char *convert_format(unsigned char *data, int img_n, int req_comp, uint x, uint y)
+{
+ int i,j;
+ unsigned char *good;
+
+ if (req_comp == img_n) return data;
+ assert(req_comp >= 1 && req_comp <= 4);
+
+ good = (unsigned char *) malloc(req_comp * x * y);
+ if (good == NULL) {
+ free(data);
+ return epuc("outofmem", "Out of memory");
+ }
+
+ for (j=0; j < (int) y; ++j) {
+ unsigned char *src = data + j * x * img_n ;
+ unsigned char *dest = good + j * x * req_comp;
+
+ #define COMBO(a,b) ((a)*8+(b))
+ #define CASE(a,b) case COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
+ // convert source image with img_n components to one with req_comp components;
+ // avoid switch per pixel, so use switch per scanline and massive macros
+ switch (COMBO(img_n, req_comp)) {
+ CASE(1,2) dest[0]=src[0], dest[1]=255; break;
+ CASE(1,3) dest[0]=dest[1]=dest[2]=src[0]; break;
+ CASE(1,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; break;
+ CASE(2,1) dest[0]=src[0]; break;
+ CASE(2,3) dest[0]=dest[1]=dest[2]=src[0]; break;
+ CASE(2,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; break;
+ CASE(3,4) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; break;
+ CASE(3,1) dest[0]=compute_y(src[0],src[1],src[2]); break;
+ CASE(3,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = 255; break;
+ CASE(4,1) dest[0]=compute_y(src[0],src[1],src[2]); break;
+ CASE(4,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = src[3]; break;
+ CASE(4,3) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; break;
+ default: assert(0);
+ }
+ #undef CASE
+ }
+
+ free(data);
+ return good;
+}
+
+#ifndef STBI_NO_HDR
+static float *ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
+{
+ int i,k,n;
+ float *output = (float *) malloc(x * y * comp * sizeof(float));
+ if (output == NULL) { free(data); return epf("outofmem", "Out of memory"); }
+ // compute number of non-alpha components
+ if (comp & 1) n = comp; else n = comp-1;
+ for (i=0; i < x*y; ++i) {
+ for (k=0; k < n; ++k) {
+ output[i*comp + k] = (float) pow(data[i*comp+k]/255.0f, l2h_gamma) * l2h_scale;
+ }
+ if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
+ }
+ free(data);
+ return output;
+}
+
+#define float2int(x) ((int) (x))
+static stbi_uc *hdr_to_ldr(float *data, int x, int y, int comp)
+{
+ int i,k,n;
+ stbi_uc *output = (stbi_uc *) malloc(x * y * comp);
+ if (output == NULL) { free(data); return epuc("outofmem", "Out of memory"); }
+ // compute number of non-alpha components
+ if (comp & 1) n = comp; else n = comp-1;
+ for (i=0; i < x*y; ++i) {
+ for (k=0; k < n; ++k) {
+ float z = (float) pow(data[i*comp+k]*h2l_scale_i, h2l_gamma_i) * 255 + 0.5f;
+ if (z < 0) z = 0;
+ if (z > 255) z = 255;
+ output[i*comp + k] = (uint8) float2int(z);
+ }
+ if (k < comp) {
+ float z = data[i*comp+k] * 255 + 0.5f;
+ if (z < 0) z = 0;
+ if (z > 255) z = 255;
+ output[i*comp + k] = (uint8) float2int(z);
+ }
+ }
+ free(data);
+ return output;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// "baseline" JPEG/JFIF decoder (not actually fully baseline implementation)
+//
+// simple implementation
+// - channel subsampling of at most 2 in each dimension
+// - doesn't support delayed output of y-dimension
+// - simple interface (only one output format: 8-bit interleaved RGB)
+// - doesn't try to recover corrupt jpegs
+// - doesn't allow partial loading, loading multiple at once
+// - still fast on x86 (copying globals into locals doesn't help x86)
+// - allocates lots of intermediate memory (full size of all components)
+// - non-interleaved case requires this anyway
+// - allows good upsampling (see next)
+// high-quality
+// - upsampled channels are bilinearly interpolated, even across blocks
+// - quality integer IDCT derived from IJG's 'slow'
+// performance
+// - fast huffman; reasonable integer IDCT
+// - uses a lot of intermediate memory, could cache poorly
+// - load http://nothings.org/remote/anemones.jpg 3 times on 2.8Ghz P4
+// stb_jpeg: 1.34 seconds (MSVC6, default release build)
+// stb_jpeg: 1.06 seconds (MSVC6, processor = Pentium Pro)
+// IJL11.dll: 1.08 seconds (compiled by intel)
+// IJG 1998: 0.98 seconds (MSVC6, makefile provided by IJG)
+// IJG 1998: 0.95 seconds (MSVC6, makefile + proc=PPro)
+
+// huffman decoding acceleration
+#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache
+
+typedef struct
+{
+ uint8 fast[1 << FAST_BITS];
+ // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
+ uint16 code[256];
+ uint8 values[256];
+ uint8 size[257];
+ unsigned int maxcode[18];
+ int delta[17]; // old 'firstsymbol' - old 'firstcode'
+} huffman;
+
+typedef struct
+{
+ #ifdef STBI_SIMD
+ unsigned short dequant2[4][64];
+ #endif
+ stbi *s;
+ huffman huff_dc[4];
+ huffman huff_ac[4];
+ uint8 dequant[4][64];
+
+// sizes for components, interleaved MCUs
+ int img_h_max, img_v_max;
+ int img_mcu_x, img_mcu_y;
+ int img_mcu_w, img_mcu_h;
+
+// definition of jpeg image component
+ struct
+ {
+ int id;
+ int h,v;
+ int tq;
+ int hd,ha;
+ int dc_pred;
+
+ int x,y,w2,h2;
+ uint8 *data;
+ void *raw_data;
+ uint8 *linebuf;
+ } img_comp[4];
+
+ uint32 code_buffer; // jpeg entropy-coded buffer
+ int code_bits; // number of valid bits
+ unsigned char marker; // marker seen while filling entropy buffer
+ int nomore; // flag if we saw a marker so must stop
+
+ int scan_n, order[4];
+ int restart_interval, todo;
+} jpeg;
+
+static int build_huffman(huffman *h, int *count)
+{
+ int i,j,k=0,code;
+ // build size list for each symbol (from JPEG spec)
+ for (i=0; i < 16; ++i)
+ for (j=0; j < count[i]; ++j)
+ h->size[k++] = (uint8) (i+1);
+ h->size[k] = 0;
+
+ // compute actual symbols (from jpeg spec)
+ code = 0;
+ k = 0;
+ for(j=1; j <= 16; ++j) {
+ // compute delta to add to code to compute symbol id
+ h->delta[j] = k - code;
+ if (h->size[k] == j) {
+ while (h->size[k] == j)
+ h->code[k++] = (uint16) (code++);
+ if (code-1 >= (1 << j)) return e("bad code lengths","Corrupt JPEG");
+ }
+ // compute largest code + 1 for this size, preshifted as needed later
+ h->maxcode[j] = code << (16-j);
+ code <<= 1;
+ }
+ h->maxcode[j] = 0xffffffff;
+
+ // build non-spec acceleration table; 255 is flag for not-accelerated
+ memset(h->fast, 255, 1 << FAST_BITS);
+ for (i=0; i < k; ++i) {
+ int s = h->size[i];
+ if (s <= FAST_BITS) {
+ int c = h->code[i] << (FAST_BITS-s);
+ int m = 1 << (FAST_BITS-s);
+ for (j=0; j < m; ++j) {
+ h->fast[c+j] = (uint8) i;
+ }
+ }
+ }
+ return 1;
+}
+
+static void grow_buffer_unsafe(jpeg *j)
+{
+ do {
+ int b = j->nomore ? 0 : get8(j->s);
+ if (b == 0xff) {
+ int c = get8(j->s);
+ if (c != 0) {
+ j->marker = (unsigned char) c;
+ j->nomore = 1;
+ return;
+ }
+ }
+ j->code_buffer |= b << (24 - j->code_bits);
+ j->code_bits += 8;
+ } while (j->code_bits <= 24);
+}
+
+// (1 << n) - 1
+static uint32 bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
+
+// decode a jpeg huffman value from the bitstream
+stbi_inline static int decode(jpeg *j, huffman *h)
+{
+ unsigned int temp;
+ int c,k;
+
+ if (j->code_bits < 16) grow_buffer_unsafe(j);
+
+ // look at the top FAST_BITS and determine what symbol ID it is,
+ // if the code is <= FAST_BITS
+ c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+ k = h->fast[c];
+ if (k < 255) {
+ int s = h->size[k];
+ if (s > j->code_bits)
+ return -1;
+ j->code_buffer <<= s;
+ j->code_bits -= s;
+ return h->values[k];
+ }
+
+ // naive test is to shift the code_buffer down so k bits are
+ // valid, then test against maxcode. To speed this up, we've
+ // preshifted maxcode left so that it has (16-k) 0s at the
+ // end; in other words, regardless of the number of bits, it
+ // wants to be compared against something shifted to have 16;
+ // that way we don't need to shift inside the loop.
+ temp = j->code_buffer >> 16;
+ for (k=FAST_BITS+1 ; ; ++k)
+ if (temp < h->maxcode[k])
+ break;
+ if (k == 17) {
+ // error! code not found
+ j->code_bits -= 16;
+ return -1;
+ }
+
+ if (k > j->code_bits)
+ return -1;
+
+ // convert the huffman code to the symbol id
+ c = ((j->code_buffer >> (32 - k)) & bmask[k]) + h->delta[k];
+ assert((((j->code_buffer) >> (32 - h->size[c])) & bmask[h->size[c]]) == h->code[c]);
+
+ // convert the id to a symbol
+ j->code_bits -= k;
+ j->code_buffer <<= k;
+ return h->values[c];
+}
+
+// combined JPEG 'receive' and JPEG 'extend', since baseline
+// always extends everything it receives.
+stbi_inline static int extend_receive(jpeg *j, int n)
+{
+ unsigned int m = 1 << (n-1);
+ unsigned int k;
+ if (j->code_bits < n) grow_buffer_unsafe(j);
+
+ #if 1
+ k = stbi_lrot(j->code_buffer, n);
+ j->code_buffer = k & ~bmask[n];
+ k &= bmask[n];
+ j->code_bits -= n;
+ #else
+ k = (j->code_buffer >> (32 - n)) & bmask[n];
+ j->code_bits -= n;
+ j->code_buffer <<= n;
+ #endif
+ // the following test is probably a random branch that won't
+ // predict well. I tried to table accelerate it but failed.
+ // maybe it's compiling as a conditional move?
+ if (k < m)
+ return (-1 << n) + k + 1;
+ else
+ return k;
+}
+
+// given a value that's at position X in the zigzag stream,
+// where does it appear in the 8x8 matrix coded as row-major?
+static uint8 dezigzag[64+15] =
+{
+ 0, 1, 8, 16, 9, 2, 3, 10,
+ 17, 24, 32, 25, 18, 11, 4, 5,
+ 12, 19, 26, 33, 40, 48, 41, 34,
+ 27, 20, 13, 6, 7, 14, 21, 28,
+ 35, 42, 49, 56, 57, 50, 43, 36,
+ 29, 22, 15, 23, 30, 37, 44, 51,
+ 58, 59, 52, 45, 38, 31, 39, 46,
+ 53, 60, 61, 54, 47, 55, 62, 63,
+ // let corrupt input sample past end
+ 63, 63, 63, 63, 63, 63, 63, 63,
+ 63, 63, 63, 63, 63, 63, 63
+};
+
+// decode one 64-entry block--
+static int decode_block(jpeg *j, short data[64], huffman *hdc, huffman *hac, int b)
+{
+ int diff,dc,k;
+ int t = decode(j, hdc);
+ if (t < 0) return e("bad huffman code","Corrupt JPEG");
+
+ // 0 all the ac values now so we can do it 32-bits at a time
+ memset(data,0,64*sizeof(data[0]));
+
+ diff = t ? extend_receive(j, t) : 0;
+ dc = j->img_comp[b].dc_pred + diff;
+ j->img_comp[b].dc_pred = dc;
+ data[0] = (short) dc;
+
+ // decode AC components, see JPEG spec
+ k = 1;
+ do {
+ int r,s;
+ int rs = decode(j, hac);
+ if (rs < 0) return e("bad huffman code","Corrupt JPEG");
+ s = rs & 15;
+ r = rs >> 4;
+ if (s == 0) {
+ if (rs != 0xf0) break; // end block
+ k += 16;
+ } else {
+ k += r;
+ // decode into unzigzag'd location
+ data[dezigzag[k++]] = (short) extend_receive(j,s);
+ }
+ } while (k < 64);
+ return 1;
+}
+
+// take a -128..127 value and clamp it and convert to 0..255
+stbi_inline static uint8 clamp(int x)
+{
+ // trick to use a single test to catch both cases
+ if ((unsigned int) x > 255) {
+ if (x < 0) return 0;
+ if (x > 255) return 255;
+ }
+ return (uint8) x;
+}
+
+#define f2f(x) (int) (((x) * 4096 + 0.5))
+#define fsh(x) ((x) << 12)
+
+// derived from jidctint -- DCT_ISLOW
+#define IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
+ int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
+ p2 = s2; \
+ p3 = s6; \
+ p1 = (p2+p3) * f2f(0.5411961f); \
+ t2 = p1 + p3*f2f(-1.847759065f); \
+ t3 = p1 + p2*f2f( 0.765366865f); \
+ p2 = s0; \
+ p3 = s4; \
+ t0 = fsh(p2+p3); \
+ t1 = fsh(p2-p3); \
+ x0 = t0+t3; \
+ x3 = t0-t3; \
+ x1 = t1+t2; \
+ x2 = t1-t2; \
+ t0 = s7; \
+ t1 = s5; \
+ t2 = s3; \
+ t3 = s1; \
+ p3 = t0+t2; \
+ p4 = t1+t3; \
+ p1 = t0+t3; \
+ p2 = t1+t2; \
+ p5 = (p3+p4)*f2f( 1.175875602f); \
+ t0 = t0*f2f( 0.298631336f); \
+ t1 = t1*f2f( 2.053119869f); \
+ t2 = t2*f2f( 3.072711026f); \
+ t3 = t3*f2f( 1.501321110f); \
+ p1 = p5 + p1*f2f(-0.899976223f); \
+ p2 = p5 + p2*f2f(-2.562915447f); \
+ p3 = p3*f2f(-1.961570560f); \
+ p4 = p4*f2f(-0.390180644f); \
+ t3 += p1+p4; \
+ t2 += p2+p3; \
+ t1 += p2+p4; \
+ t0 += p1+p3;
+
+#ifdef STBI_SIMD
+typedef unsigned short stbi_dequantize_t;
+#else
+typedef uint8 stbi_dequantize_t;
+#endif
+
+// .344 seconds on 3*anemones.jpg
+static void idct_block(uint8 *out, int out_stride, short data[64], stbi_dequantize_t *dequantize)
+{
+ int i,val[64],*v=val;
+ stbi_dequantize_t *dq = dequantize;
+ uint8 *o;
+ short *d = data;
+
+ // columns
+ for (i=0; i < 8; ++i,++d,++dq, ++v) {
+ // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
+ if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
+ && d[40]==0 && d[48]==0 && d[56]==0) {
+ // no shortcut 0 seconds
+ // (1|2|3|4|5|6|7)==0 0 seconds
+ // all separate -0.047 seconds
+ // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds
+ int dcterm = d[0] * dq[0] << 2;
+ v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
+ } else {
+ IDCT_1D(d[ 0]*dq[ 0],d[ 8]*dq[ 8],d[16]*dq[16],d[24]*dq[24],
+ d[32]*dq[32],d[40]*dq[40],d[48]*dq[48],d[56]*dq[56])
+ // constants scaled things up by 1<<12; let's bring them back
+ // down, but keep 2 extra bits of precision
+ x0 += 512; x1 += 512; x2 += 512; x3 += 512;
+ v[ 0] = (x0+t3) >> 10;
+ v[56] = (x0-t3) >> 10;
+ v[ 8] = (x1+t2) >> 10;
+ v[48] = (x1-t2) >> 10;
+ v[16] = (x2+t1) >> 10;
+ v[40] = (x2-t1) >> 10;
+ v[24] = (x3+t0) >> 10;
+ v[32] = (x3-t0) >> 10;
+ }
+ }
+
+ for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
+ // no fast case since the first 1D IDCT spread components out
+ IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
+ // constants scaled things up by 1<<12, plus we had 1<<2 from first
+ // loop, plus horizontal and vertical each scale by sqrt(8) so together
+ // we've got an extra 1<<3, so 1<<17 total we need to remove.
+ // so we want to round that, which means adding 0.5 * 1<<17,
+ // aka 65536. Also, we'll end up with -128 to 127 that we want
+ // to encode as 0..255 by adding 128, so we'll add that before the shift
+ x0 += 65536 + (128<<17);
+ x1 += 65536 + (128<<17);
+ x2 += 65536 + (128<<17);
+ x3 += 65536 + (128<<17);
+ // tried computing the shifts into temps, or'ing the temps to see
+ // if any were out of range, but that was slower
+ o[0] = clamp((x0+t3) >> 17);
+ o[7] = clamp((x0-t3) >> 17);
+ o[1] = clamp((x1+t2) >> 17);
+ o[6] = clamp((x1-t2) >> 17);
+ o[2] = clamp((x2+t1) >> 17);
+ o[5] = clamp((x2-t1) >> 17);
+ o[3] = clamp((x3+t0) >> 17);
+ o[4] = clamp((x3-t0) >> 17);
+ }
+}
+
+#ifdef STBI_SIMD
+static stbi_idct_8x8 stbi_idct_installed = idct_block;
+
+void stbi_install_idct(stbi_idct_8x8 func)
+{
+ stbi_idct_installed = func;
+}
+#endif
+
+#define MARKER_none 0xff
+// if there's a pending marker from the entropy stream, return that
+// otherwise, fetch from the stream and get a marker. if there's no
+// marker, return 0xff, which is never a valid marker value
+static uint8 get_marker(jpeg *j)
+{
+ uint8 x;
+ if (j->marker != MARKER_none) { x = j->marker; j->marker = MARKER_none; return x; }
+ x = get8u(j->s);
+ if (x != 0xff) return MARKER_none;
+ while (x == 0xff)
+ x = get8u(j->s);
+ return x;
+}
+
+// in each scan, we'll have scan_n components, and the order
+// of the components is specified by order[]
+#define RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)
+
+// after a restart interval, reset the entropy decoder and
+// the dc prediction
+static void reset(jpeg *j)
+{
+ j->code_bits = 0;
+ j->code_buffer = 0;
+ j->nomore = 0;
+ j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = 0;
+ j->marker = MARKER_none;
+ j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
+ // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
+ // since we don't even allow 1<<30 pixels
+}
+
+static int parse_entropy_coded_data(jpeg *z)
+{
+ reset(z);
+ if (z->scan_n == 1) {
+ int i,j;
+ #ifdef STBI_SIMD
+ __declspec(align(16))
+ #endif
+ short data[64];
+ int n = z->order[0];
+ // non-interleaved data, we just need to process one block at a time,
+ // in trivial scanline order
+ // number of blocks to do just depends on how many actual "pixels" this
+ // component has, independent of interleaved MCU blocking and such
+ int w = (z->img_comp[n].x+7) >> 3;
+ int h = (z->img_comp[n].y+7) >> 3;
+ for (j=0; j < h; ++j) {
+ for (i=0; i < w; ++i) {
+ if (!decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0;
+ #ifdef STBI_SIMD
+ stbi_idct_installed(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]);
+ #else
+ idct_block(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]);
+ #endif
+ // every data block is an MCU, so countdown the restart interval
+ if (--z->todo <= 0) {
+ if (z->code_bits < 24) grow_buffer_unsafe(z);
+ // if it's NOT a restart, then just bail, so we get corrupt data
+ // rather than no data
+ if (!RESTART(z->marker)) return 1;
+ reset(z);
+ }
+ }
+ }
+ } else { // interleaved!
+ int i,j,k,x,y;
+ short data[64];
+ for (j=0; j < z->img_mcu_y; ++j) {
+ for (i=0; i < z->img_mcu_x; ++i) {
+ // scan an interleaved mcu... process scan_n components in order
+ for (k=0; k < z->scan_n; ++k) {
+ int n = z->order[k];
+ // scan out an mcu's worth of this component; that's just determined
+ // by the basic H and V specified for the component
+ for (y=0; y < z->img_comp[n].v; ++y) {
+ for (x=0; x < z->img_comp[n].h; ++x) {
+ int x2 = (i*z->img_comp[n].h + x)*8;
+ int y2 = (j*z->img_comp[n].v + y)*8;
+ if (!decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0;
+ #ifdef STBI_SIMD
+ stbi_idct_installed(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]);
+ #else
+ idct_block(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]);
+ #endif
+ }
+ }
+ }
+ // after all interleaved components, that's an interleaved MCU,
+ // so now count down the restart interval
+ if (--z->todo <= 0) {
+ if (z->code_bits < 24) grow_buffer_unsafe(z);
+ // if it's NOT a restart, then just bail, so we get corrupt data
+ // rather than no data
+ if (!RESTART(z->marker)) return 1;
+ reset(z);
+ }
+ }
+ }
+ }
+ return 1;
+}
+
+static int process_marker(jpeg *z, int m)
+{
+ int L;
+ switch (m) {
+ case MARKER_none: // no marker found
+ return e("expected marker","Corrupt JPEG");
+
+ case 0xC2: // SOF - progressive
+ return e("progressive jpeg","JPEG format not supported (progressive)");
+
+ case 0xDD: // DRI - specify restart interval
+ if (get16(z->s) != 4) return e("bad DRI len","Corrupt JPEG");
+ z->restart_interval = get16(z->s);
+ return 1;
+
+ case 0xDB: // DQT - define quantization table
+ L = get16(z->s)-2;
+ while (L > 0) {
+ int q = get8(z->s);
+ int p = q >> 4;
+ int t = q & 15,i;
+ if (p != 0) return e("bad DQT type","Corrupt JPEG");
+ if (t > 3) return e("bad DQT table","Corrupt JPEG");
+ for (i=0; i < 64; ++i)
+ z->dequant[t][dezigzag[i]] = get8u(z->s);
+ #ifdef STBI_SIMD
+ for (i=0; i < 64; ++i)
+ z->dequant2[t][i] = z->dequant[t][i];
+ #endif
+ L -= 65;
+ }
+ return L==0;
+
+ case 0xC4: // DHT - define huffman table
+ L = get16(z->s)-2;
+ while (L > 0) {
+ uint8 *v;
+ int sizes[16],i,m=0;
+ int q = get8(z->s);
+ int tc = q >> 4;
+ int th = q & 15;
+ if (tc > 1 || th > 3) return e("bad DHT header","Corrupt JPEG");
+ for (i=0; i < 16; ++i) {
+ sizes[i] = get8(z->s);
+ m += sizes[i];
+ }
+ L -= 17;
+ if (tc == 0) {
+ if (!build_huffman(z->huff_dc+th, sizes)) return 0;
+ v = z->huff_dc[th].values;
+ } else {
+ if (!build_huffman(z->huff_ac+th, sizes)) return 0;
+ v = z->huff_ac[th].values;
+ }
+ for (i=0; i < m; ++i)
+ v[i] = get8u(z->s);
+ L -= m;
+ }
+ return L==0;
+ }
+ // check for comment block or APP blocks
+ if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
+ skip(z->s, get16(z->s)-2);
+ return 1;
+ }
+ return 0;
+}
+
+// after we see SOS
+static int process_scan_header(jpeg *z)
+{
+ int i;
+ int Ls = get16(z->s);
+ z->scan_n = get8(z->s);
+ if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return e("bad SOS component count","Corrupt JPEG");
+ if (Ls != 6+2*z->scan_n) return e("bad SOS len","Corrupt JPEG");
+ for (i=0; i < z->scan_n; ++i) {
+ int id = get8(z->s), which;
+ int q = get8(z->s);
+ for (which = 0; which < z->s->img_n; ++which)
+ if (z->img_comp[which].id == id)
+ break;
+ if (which == z->s->img_n) return 0;
+ z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return e("bad DC huff","Corrupt JPEG");
+ z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return e("bad AC huff","Corrupt JPEG");
+ z->order[i] = which;
+ }
+ if (get8(z->s) != 0) return e("bad SOS","Corrupt JPEG");
+ get8(z->s); // should be 63, but might be 0
+ if (get8(z->s) != 0) return e("bad SOS","Corrupt JPEG");
+
+ return 1;
+}
+
+static int process_frame_header(jpeg *z, int scan)
+{
+ stbi *s = z->s;
+ int Lf,p,i,q, h_max=1,v_max=1,c;
+ Lf = get16(s); if (Lf < 11) return e("bad SOF len","Corrupt JPEG"); // JPEG
+ p = get8(s); if (p != 8) return e("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
+ s->img_y = get16(s); if (s->img_y == 0) return e("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
+ s->img_x = get16(s); if (s->img_x == 0) return e("0 width","Corrupt JPEG"); // JPEG requires
+ c = get8(s);
+ if (c != 3 && c != 1) return e("bad component count","Corrupt JPEG"); // JFIF requires
+ s->img_n = c;
+ for (i=0; i < c; ++i) {
+ z->img_comp[i].data = NULL;
+ z->img_comp[i].linebuf = NULL;
+ }
+
+ if (Lf != 8+3*s->img_n) return e("bad SOF len","Corrupt JPEG");
+
+ for (i=0; i < s->img_n; ++i) {
+ z->img_comp[i].id = get8(s);
+ if (z->img_comp[i].id != i+1) // JFIF requires
+ if (z->img_comp[i].id != i) // some version of jpegtran outputs non-JFIF-compliant files!
+ return e("bad component ID","Corrupt JPEG");
+ q = get8(s);
+ z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return e("bad H","Corrupt JPEG");
+ z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return e("bad V","Corrupt JPEG");
+ z->img_comp[i].tq = get8(s); if (z->img_comp[i].tq > 3) return e("bad TQ","Corrupt JPEG");
+ }
+
+ if (scan != SCAN_load) return 1;
+
+ if ((1 << 30) / s->img_x / s->img_n < s->img_y) return e("too large", "Image too large to decode");
+
+ for (i=0; i < s->img_n; ++i) {
+ if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
+ if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
+ }
+
+ // compute interleaved mcu info
+ z->img_h_max = h_max;
+ z->img_v_max = v_max;
+ z->img_mcu_w = h_max * 8;
+ z->img_mcu_h = v_max * 8;
+ z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
+ z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
+
+ for (i=0; i < s->img_n; ++i) {
+ // number of effective pixels (e.g. for non-interleaved MCU)
+ z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
+ z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
+ // to simplify generation, we'll allocate enough memory to decode
+ // the bogus oversized data from using interleaved MCUs and their
+ // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
+ // discard the extra data until colorspace conversion
+ z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
+ z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
+ z->img_comp[i].raw_data = malloc(z->img_comp[i].w2 * z->img_comp[i].h2+15);
+ if (z->img_comp[i].raw_data == NULL) {
+ for(--i; i >= 0; --i) {
+ free(z->img_comp[i].raw_data);
+ z->img_comp[i].data = NULL;
+ }
+ return e("outofmem", "Out of memory");
+ }
+ // align blocks for installable-idct using mmx/sse
+ z->img_comp[i].data = (uint8*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
+ z->img_comp[i].linebuf = NULL;
+ }
+
+ return 1;
+}
+
+// use comparisons since in some cases we handle more than one case (e.g. SOF)
+#define DNL(x) ((x) == 0xdc)
+#define SOI(x) ((x) == 0xd8)
+#define EOI(x) ((x) == 0xd9)
+#define SOF(x) ((x) == 0xc0 || (x) == 0xc1)
+#define SOS(x) ((x) == 0xda)
+
+static int decode_jpeg_header(jpeg *z, int scan)
+{
+ int m;
+ z->marker = MARKER_none; // initialize cached marker to empty
+ m = get_marker(z);
+ if (!SOI(m)) return e("no SOI","Corrupt JPEG");
+ if (scan == SCAN_type) return 1;
+ m = get_marker(z);
+ while (!SOF(m)) {
+ if (!process_marker(z,m)) return 0;
+ m = get_marker(z);
+ while (m == MARKER_none) {
+ // some files have extra padding after their blocks, so ok, we'll scan
+ if (at_eof(z->s)) return e("no SOF", "Corrupt JPEG");
+ m = get_marker(z);
+ }
+ }
+ if (!process_frame_header(z, scan)) return 0;
+ return 1;
+}
+
+static int decode_jpeg_image(jpeg *j)
+{
+ int m;
+ j->restart_interval = 0;
+ if (!decode_jpeg_header(j, SCAN_load)) return 0;
+ m = get_marker(j);
+ while (!EOI(m)) {
+ if (SOS(m)) {
+ if (!process_scan_header(j)) return 0;
+ if (!parse_entropy_coded_data(j)) return 0;
+ if (j->marker == MARKER_none ) {
+ // handle 0s at the end of image data from IP Kamera 9060
+ while (!at_eof(j->s)) {
+ int x = get8(j->s);
+ if (x == 255) {
+ j->marker = get8u(j->s);
+ break;
+ } else if (x != 0) {
+ return 0;
+ }
+ }
+ // if we reach eof without hitting a marker, get_marker() below will fail and we'll eventually return 0
+ }
+ } else {
+ if (!process_marker(j, m)) return 0;
+ }
+ m = get_marker(j);
+ }
+ return 1;
+}
+
+// static jfif-centered resampling (across block boundaries)
+
+typedef uint8 *(*resample_row_func)(uint8 *out, uint8 *in0, uint8 *in1,
+ int w, int hs);
+
+#define div4(x) ((uint8) ((x) >> 2))
+
+static uint8 *resample_row_1(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
+{
+ STBI_NOTUSED(out);
+ STBI_NOTUSED(in_far);
+ STBI_NOTUSED(w);
+ STBI_NOTUSED(hs);
+ return in_near;
+}
+
+static uint8* resample_row_v_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
+{
+ // need to generate two samples vertically for every one in input
+ int i;
+ STBI_NOTUSED(hs);
+ for (i=0; i < w; ++i)
+ out[i] = div4(3*in_near[i] + in_far[i] + 2);
+ return out;
+}
+
+static uint8* resample_row_h_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
+{
+ // need to generate two samples horizontally for every one in input
+ int i;
+ uint8 *input = in_near;
+
+ if (w == 1) {
+ // if only one sample, can't do any interpolation
+ out[0] = out[1] = input[0];
+ return out;
+ }
+
+ out[0] = input[0];
+ out[1] = div4(input[0]*3 + input[1] + 2);
+ for (i=1; i < w-1; ++i) {
+ int n = 3*input[i]+2;
+ out[i*2+0] = div4(n+input[i-1]);
+ out[i*2+1] = div4(n+input[i+1]);
+ }
+ out[i*2+0] = div4(input[w-2]*3 + input[w-1] + 2);
+ out[i*2+1] = input[w-1];
+
+ STBI_NOTUSED(in_far);
+ STBI_NOTUSED(hs);
+
+ return out;
+}
+
+#define div16(x) ((uint8) ((x) >> 4))
+
+static uint8 *resample_row_hv_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
+{
+ // need to generate 2x2 samples for every one in input
+ int i,t0,t1;
+ if (w == 1) {
+ out[0] = out[1] = div4(3*in_near[0] + in_far[0] + 2);
+ return out;
+ }
+
+ t1 = 3*in_near[0] + in_far[0];
+ out[0] = div4(t1+2);
+ for (i=1; i < w; ++i) {
+ t0 = t1;
+ t1 = 3*in_near[i]+in_far[i];
+ out[i*2-1] = div16(3*t0 + t1 + 8);
+ out[i*2 ] = div16(3*t1 + t0 + 8);
+ }
+ out[w*2-1] = div4(t1+2);
+
+ STBI_NOTUSED(hs);
+
+ return out;
+}
+
+static uint8 *resample_row_generic(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs)
+{
+ // resample with nearest-neighbor
+ int i,j;
+ STBI_NOTUSED(in_far);
+ for (i=0; i < w; ++i)
+ for (j=0; j < hs; ++j)
+ out[i*hs+j] = in_near[i];
+ return out;
+}
+
+#define float2fixed(x) ((int) ((x) * 65536 + 0.5))
+
+// 0.38 seconds on 3*anemones.jpg (0.25 with processor = Pro)
+// VC6 without processor=Pro is generating multiple LEAs per multiply!
+static void YCbCr_to_RGB_row(uint8 *out, const uint8 *y, const uint8 *pcb, const uint8 *pcr, int count, int step)
+{
+ int i;
+ for (i=0; i < count; ++i) {
+ int y_fixed = (y[i] << 16) + 32768; // rounding
+ int r,g,b;
+ int cr = pcr[i] - 128;
+ int cb = pcb[i] - 128;
+ r = y_fixed + cr*float2fixed(1.40200f);
+ g = y_fixed - cr*float2fixed(0.71414f) - cb*float2fixed(0.34414f);
+ b = y_fixed + cb*float2fixed(1.77200f);
+ r >>= 16;
+ g >>= 16;
+ b >>= 16;
+ if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
+ if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
+ if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
+ out[0] = (uint8)r;
+ out[1] = (uint8)g;
+ out[2] = (uint8)b;
+ out[3] = 255;
+ out += step;
+ }
+}
+
+#ifdef STBI_SIMD
+static stbi_YCbCr_to_RGB_run stbi_YCbCr_installed = YCbCr_to_RGB_row;
+
+void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func)
+{
+ stbi_YCbCr_installed = func;
+}
+#endif
+
+
+// clean up the temporary component buffers
+static void cleanup_jpeg(jpeg *j)
+{
+ int i;
+ for (i=0; i < j->s->img_n; ++i) {
+ if (j->img_comp[i].data) {
+ free(j->img_comp[i].raw_data);
+ j->img_comp[i].data = NULL;
+ }
+ if (j->img_comp[i].linebuf) {
+ free(j->img_comp[i].linebuf);
+ j->img_comp[i].linebuf = NULL;
+ }
+ }
+}
+
+typedef struct
+{
+ resample_row_func resample;
+ uint8 *line0,*line1;
+ int hs,vs; // expansion factor in each axis
+ int w_lores; // horizontal pixels pre-expansion
+ int ystep; // how far through vertical expansion we are
+ int ypos; // which pre-expansion row we're on
+} stbi_resample;
+
+static uint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
+{
+ int n, decode_n;
+ // validate req_comp
+ if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error");
+ z->s->img_n = 0;
+
+ // load a jpeg image from whichever source
+ if (!decode_jpeg_image(z)) { cleanup_jpeg(z); return NULL; }
+
+ // determine actual number of components to generate
+ n = req_comp ? req_comp : z->s->img_n;
+
+ if (z->s->img_n == 3 && n < 3)
+ decode_n = 1;
+ else
+ decode_n = z->s->img_n;
+
+ // resample and color-convert
+ {
+ int k;
+ uint i,j;
+ uint8 *output;
+ uint8 *coutput[4];
+
+ stbi_resample res_comp[4];
+
+ for (k=0; k < decode_n; ++k) {
+ stbi_resample *r = &res_comp[k];
+
+ // allocate line buffer big enough for upsampling off the edges
+ // with upsample factor of 4
+ z->img_comp[k].linebuf = (uint8 *) malloc(z->s->img_x + 3);
+ if (!z->img_comp[k].linebuf) { cleanup_jpeg(z); return epuc("outofmem", "Out of memory"); }
+
+ r->hs = z->img_h_max / z->img_comp[k].h;
+ r->vs = z->img_v_max / z->img_comp[k].v;
+ r->ystep = r->vs >> 1;
+ r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
+ r->ypos = 0;
+ r->line0 = r->line1 = z->img_comp[k].data;
+
+ if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
+ else if (r->hs == 1 && r->vs == 2) r->resample = resample_row_v_2;
+ else if (r->hs == 2 && r->vs == 1) r->resample = resample_row_h_2;
+ else if (r->hs == 2 && r->vs == 2) r->resample = resample_row_hv_2;
+ else r->resample = resample_row_generic;
+ }
+
+ // can't error after this so, this is safe
+ output = (uint8 *) malloc(n * z->s->img_x * z->s->img_y + 1);
+ if (!output) { cleanup_jpeg(z); return epuc("outofmem", "Out of memory"); }
+
+ // now go ahead and resample
+ for (j=0; j < z->s->img_y; ++j) {
+ uint8 *out = output + n * z->s->img_x * j;
+ for (k=0; k < decode_n; ++k) {
+ stbi_resample *r = &res_comp[k];
+ int y_bot = r->ystep >= (r->vs >> 1);
+ coutput[k] = r->resample(z->img_comp[k].linebuf,
+ y_bot ? r->line1 : r->line0,
+ y_bot ? r->line0 : r->line1,
+ r->w_lores, r->hs);
+ if (++r->ystep >= r->vs) {
+ r->ystep = 0;
+ r->line0 = r->line1;
+ if (++r->ypos < z->img_comp[k].y)
+ r->line1 += z->img_comp[k].w2;
+ }
+ }
+ if (n >= 3) {
+ uint8 *y = coutput[0];
+ if (z->s->img_n == 3) {
+ #ifdef STBI_SIMD
+ stbi_YCbCr_installed(out, y, coutput[1], coutput[2], z->s.img_x, n);
+ #else
+ YCbCr_to_RGB_row(out, y, coutput[1], coutput[2], z->s->img_x, n);
+ #endif
+ } else
+ for (i=0; i < z->s->img_x; ++i) {
+ out[0] = out[1] = out[2] = y[i];
+ out[3] = 255; // not used if n==3
+ out += n;
+ }
+ } else {
+ uint8 *y = coutput[0];
+ if (n == 1)
+ for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
+ else
+ for (i=0; i < z->s->img_x; ++i) *out++ = y[i], *out++ = 255;
+ }
+ }
+ cleanup_jpeg(z);
+ *out_x = z->s->img_x;
+ *out_y = z->s->img_y;
+ if (comp) *comp = z->s->img_n; // report original components, not output
+ return output;
+ }
+}
+
+static unsigned char *stbi_jpeg_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+ jpeg j;
+ j.s = s;
+ return load_jpeg_image(&j, x,y,comp,req_comp);
+}
+
+static int stbi_jpeg_test(stbi *s)
+{
+ int r;
+ jpeg j;
+ j.s = s;
+ r = decode_jpeg_header(&j, SCAN_type);
+ stbi_rewind(s);
+ return r;
+}
+
+static int stbi_jpeg_info_raw(jpeg *j, int *x, int *y, int *comp)
+{
+ if (!decode_jpeg_header(j, SCAN_header)) {
+ stbi_rewind( j->s );
+ return 0;
+ }
+ if (x) *x = j->s->img_x;
+ if (y) *y = j->s->img_y;
+ if (comp) *comp = j->s->img_n;
+ return 1;
+}
+
+static int stbi_jpeg_info(stbi *s, int *x, int *y, int *comp)
+{
+ jpeg j;
+ j.s = s;
+ return stbi_jpeg_info_raw(&j, x, y, comp);
+}
+
+// public domain zlib decode v0.2 Sean Barrett 2006-11-18
+// simple implementation
+// - all input must be provided in an upfront buffer
+// - all output is written to a single output buffer (can malloc/realloc)
+// performance
+// - fast huffman
+
+// fast-way is faster to check than jpeg huffman, but slow way is slower
+#define ZFAST_BITS 9 // accelerate all cases in default tables
+#define ZFAST_MASK ((1 << ZFAST_BITS) - 1)
+
+// zlib-style huffman encoding
+// (jpegs packs from left, zlib from right, so can't share code)
+typedef struct
+{
+ uint16 fast[1 << ZFAST_BITS];
+ uint16 firstcode[16];
+ int maxcode[17];
+ uint16 firstsymbol[16];
+ uint8 size[288];
+ uint16 value[288];
+} zhuffman;
+
+stbi_inline static int bitreverse16(int n)
+{
+ n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1);
+ n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2);
+ n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4);
+ n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8);
+ return n;
+}
+
+stbi_inline static int bit_reverse(int v, int bits)
+{
+ assert(bits <= 16);
+ // to bit reverse n bits, reverse 16 and shift
+ // e.g. 11 bits, bit reverse and shift away 5
+ return bitreverse16(v) >> (16-bits);
+}
+
+static int zbuild_huffman(zhuffman *z, uint8 *sizelist, int num)
+{
+ int i,k=0;
+ int code, next_code[16], sizes[17];
+
+ // DEFLATE spec for generating codes
+ memset(sizes, 0, sizeof(sizes));
+ memset(z->fast, 255, sizeof(z->fast));
+ for (i=0; i < num; ++i)
+ ++sizes[sizelist[i]];
+ sizes[0] = 0;
+ for (i=1; i < 16; ++i)
+ assert(sizes[i] <= (1 << i));
+ code = 0;
+ for (i=1; i < 16; ++i) {
+ next_code[i] = code;
+ z->firstcode[i] = (uint16) code;
+ z->firstsymbol[i] = (uint16) k;
+ code = (code + sizes[i]);
+ if (sizes[i])
+ if (code-1 >= (1 << i)) return e("bad codelengths","Corrupt JPEG");
+ z->maxcode[i] = code << (16-i); // preshift for inner loop
+ code <<= 1;
+ k += sizes[i];
+ }
+ z->maxcode[16] = 0x10000; // sentinel
+ for (i=0; i < num; ++i) {
+ int s = sizelist[i];
+ if (s) {
+ int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
+ z->size[c] = (uint8)s;
+ z->value[c] = (uint16)i;
+ if (s <= ZFAST_BITS) {
+ int k = bit_reverse(next_code[s],s);
+ while (k < (1 << ZFAST_BITS)) {
+ z->fast[k] = (uint16) c;
+ k += (1 << s);
+ }
+ }
+ ++next_code[s];
+ }
+ }
+ return 1;
+}
+
+// zlib-from-memory implementation for PNG reading
+// because PNG allows splitting the zlib stream arbitrarily,
+// and it's annoying structurally to have PNG call ZLIB call PNG,
+// we require PNG read all the IDATs and combine them into a single
+// memory buffer
+
+typedef struct
+{
+ uint8 *zbuffer, *zbuffer_end;
+ int num_bits;
+ uint32 code_buffer;
+
+ char *zout;
+ char *zout_start;
+ char *zout_end;
+ int z_expandable;
+
+ zhuffman z_length, z_distance;
+} zbuf;
+
+stbi_inline static int zget8(zbuf *z)
+{
+ if (z->zbuffer >= z->zbuffer_end) return 0;
+ return *z->zbuffer++;
+}
+
+static void fill_bits(zbuf *z)
+{
+ do {
+ assert(z->code_buffer < (1U << z->num_bits));
+ z->code_buffer |= zget8(z) << z->num_bits;
+ z->num_bits += 8;
+ } while (z->num_bits <= 24);
+}
+
+stbi_inline static unsigned int zreceive(zbuf *z, int n)
+{
+ unsigned int k;
+ if (z->num_bits < n) fill_bits(z);
+ k = z->code_buffer & ((1 << n) - 1);
+ z->code_buffer >>= n;
+ z->num_bits -= n;
+ return k;
+}
+
+stbi_inline static int zhuffman_decode(zbuf *a, zhuffman *z)
+{
+ int b,s,k;
+ if (a->num_bits < 16) fill_bits(a);
+ b = z->fast[a->code_buffer & ZFAST_MASK];
+ if (b < 0xffff) {
+ s = z->size[b];
+ a->code_buffer >>= s;
+ a->num_bits -= s;
+ return z->value[b];
+ }
+
+ // not resolved by fast table, so compute it the slow way
+ // use jpeg approach, which requires MSbits at top
+ k = bit_reverse(a->code_buffer, 16);
+ for (s=ZFAST_BITS+1; ; ++s)
+ if (k < z->maxcode[s])
+ break;
+ if (s == 16) return -1; // invalid code!
+ // code size is s, so:
+ b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
+ assert(z->size[b] == s);
+ a->code_buffer >>= s;
+ a->num_bits -= s;
+ return z->value[b];
+}
+
+static int expand(zbuf *z, int n) // need to make room for n bytes
+{
+ char *q;
+ int cur, limit;
+ if (!z->z_expandable) return e("output buffer limit","Corrupt PNG");
+ cur = (int) (z->zout - z->zout_start);
+ limit = (int) (z->zout_end - z->zout_start);
+ while (cur + n > limit)
+ limit *= 2;
+ q = (char *) realloc(z->zout_start, limit);
+ if (q == NULL) return e("outofmem", "Out of memory");
+ z->zout_start = q;
+ z->zout = q + cur;
+ z->zout_end = q + limit;
+ return 1;
+}
+
+static int length_base[31] = {
+ 3,4,5,6,7,8,9,10,11,13,
+ 15,17,19,23,27,31,35,43,51,59,
+ 67,83,99,115,131,163,195,227,258,0,0 };
+
+static int length_extra[31]=
+{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
+
+static int dist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
+257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
+
+static int dist_extra[32] =
+{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
+
+static int parse_huffman_block(zbuf *a)
+{
+ for(;;) {
+ int z = zhuffman_decode(a, &a->z_length);
+ if (z < 256) {
+ if (z < 0) return e("bad huffman code","Corrupt PNG"); // error in huffman codes
+ if (a->zout >= a->zout_end) if (!expand(a, 1)) return 0;
+ *a->zout++ = (char) z;
+ } else {
+ uint8 *p;
+ int len,dist;
+ if (z == 256) return 1;
+ z -= 257;
+ len = length_base[z];
+ if (length_extra[z]) len += zreceive(a, length_extra[z]);
+ z = zhuffman_decode(a, &a->z_distance);
+ if (z < 0) return e("bad huffman code","Corrupt PNG");
+ dist = dist_base[z];
+ if (dist_extra[z]) dist += zreceive(a, dist_extra[z]);
+ if (a->zout - a->zout_start < dist) return e("bad dist","Corrupt PNG");
+ if (a->zout + len > a->zout_end) if (!expand(a, len)) return 0;
+ p = (uint8 *) (a->zout - dist);
+ while (len--)
+ *a->zout++ = *p++;
+ }
+ }
+}
+
+static int compute_huffman_codes(zbuf *a)
+{
+ static uint8 length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
+ zhuffman z_codelength;
+ uint8 lencodes[286+32+137];//padding for maximum single op
+ uint8 codelength_sizes[19];
+ int i,n;
+
+ int hlit = zreceive(a,5) + 257;
+ int hdist = zreceive(a,5) + 1;
+ int hclen = zreceive(a,4) + 4;
+
+ memset(codelength_sizes, 0, sizeof(codelength_sizes));
+ for (i=0; i < hclen; ++i) {
+ int s = zreceive(a,3);
+ codelength_sizes[length_dezigzag[i]] = (uint8) s;
+ }
+ if (!zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
+
+ n = 0;
+ while (n < hlit + hdist) {
+ int c = zhuffman_decode(a, &z_codelength);
+ assert(c >= 0 && c < 19);
+ if (c < 16)
+ lencodes[n++] = (uint8) c;
+ else if (c == 16) {
+ c = zreceive(a,2)+3;
+ memset(lencodes+n, lencodes[n-1], c);
+ n += c;
+ } else if (c == 17) {
+ c = zreceive(a,3)+3;
+ memset(lencodes+n, 0, c);
+ n += c;
+ } else {
+ assert(c == 18);
+ c = zreceive(a,7)+11;
+ memset(lencodes+n, 0, c);
+ n += c;
+ }
+ }
+ if (n != hlit+hdist) return e("bad codelengths","Corrupt PNG");
+ if (!zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
+ if (!zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
+ return 1;
+}
+
+static int parse_uncompressed_block(zbuf *a)
+{
+ uint8 header[4];
+ int len,nlen,k;
+ if (a->num_bits & 7)
+ zreceive(a, a->num_bits & 7); // discard
+ // drain the bit-packed data into header
+ k = 0;
+ while (a->num_bits > 0) {
+ header[k++] = (uint8) (a->code_buffer & 255); // wtf this warns?
+ a->code_buffer >>= 8;
+ a->num_bits -= 8;
+ }
+ assert(a->num_bits == 0);
+ // now fill header the normal way
+ while (k < 4)
+ header[k++] = (uint8) zget8(a);
+ len = header[1] * 256 + header[0];
+ nlen = header[3] * 256 + header[2];
+ if (nlen != (len ^ 0xffff)) return e("zlib corrupt","Corrupt PNG");
+ if (a->zbuffer + len > a->zbuffer_end) return e("read past buffer","Corrupt PNG");
+ if (a->zout + len > a->zout_end)
+ if (!expand(a, len)) return 0;
+ memcpy(a->zout, a->zbuffer, len);
+ a->zbuffer += len;
+ a->zout += len;
+ return 1;
+}
+
+static int parse_zlib_header(zbuf *a)
+{
+ int cmf = zget8(a);
+ int cm = cmf & 15;
+ /* int cinfo = cmf >> 4; */
+ int flg = zget8(a);
+ if ((cmf*256+flg) % 31 != 0) return e("bad zlib header","Corrupt PNG"); // zlib spec
+ if (flg & 32) return e("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
+ if (cm != 8) return e("bad compression","Corrupt PNG"); // DEFLATE required for png
+ // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
+ return 1;
+}
+
+// @TODO: should statically initialize these for optimal thread safety
+static uint8 default_length[288], default_distance[32];
+static void init_defaults(void)
+{
+ int i; // use <= to match clearly with spec
+ for (i=0; i <= 143; ++i) default_length[i] = 8;
+ for ( ; i <= 255; ++i) default_length[i] = 9;
+ for ( ; i <= 279; ++i) default_length[i] = 7;
+ for ( ; i <= 287; ++i) default_length[i] = 8;
+
+ for (i=0; i <= 31; ++i) default_distance[i] = 5;
+}
+
+int stbi_png_partial; // a quick hack to only allow decoding some of a PNG... I should implement real streaming support instead
+static int parse_zlib(zbuf *a, int parse_header)
+{
+ int final, type;
+ if (parse_header)
+ if (!parse_zlib_header(a)) return 0;
+ a->num_bits = 0;
+ a->code_buffer = 0;
+ do {
+ final = zreceive(a,1);
+ type = zreceive(a,2);
+ if (type == 0) {
+ if (!parse_uncompressed_block(a)) return 0;
+ } else if (type == 3) {
+ return 0;
+ } else {
+ if (type == 1) {
+ // use fixed code lengths
+ if (!default_distance[31]) init_defaults();
+ if (!zbuild_huffman(&a->z_length , default_length , 288)) return 0;
+ if (!zbuild_huffman(&a->z_distance, default_distance, 32)) return 0;
+ } else {
+ if (!compute_huffman_codes(a)) return 0;
+ }
+ if (!parse_huffman_block(a)) return 0;
+ }
+ if (stbi_png_partial && a->zout - a->zout_start > 65536)
+ break;
+ } while (!final);
+ return 1;
+}
+
+static int do_zlib(zbuf *a, char *obuf, int olen, int exp, int parse_header)
+{
+ a->zout_start = obuf;
+ a->zout = obuf;
+ a->zout_end = obuf + olen;
+ a->z_expandable = exp;
+
+ return parse_zlib(a, parse_header);
+}
+
+char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
+{
+ zbuf a;
+ char *p = (char *) malloc(initial_size);
+ if (p == NULL) return NULL;
+ a.zbuffer = (uint8 *) buffer;
+ a.zbuffer_end = (uint8 *) buffer + len;
+ if (do_zlib(&a, p, initial_size, 1, 1)) {
+ if (outlen) *outlen = (int) (a.zout - a.zout_start);
+ return a.zout_start;
+ } else {
+ free(a.zout_start);
+ return NULL;
+ }
+}
+
+char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
+{
+ return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
+}
+
+char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
+{
+ zbuf a;
+ char *p = (char *) malloc(initial_size);
+ if (p == NULL) return NULL;
+ a.zbuffer = (uint8 *) buffer;
+ a.zbuffer_end = (uint8 *) buffer + len;
+ if (do_zlib(&a, p, initial_size, 1, parse_header)) {
+ if (outlen) *outlen = (int) (a.zout - a.zout_start);
+ return a.zout_start;
+ } else {
+ free(a.zout_start);
+ return NULL;
+ }
+}
+
+int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
+{
+ zbuf a;
+ a.zbuffer = (uint8 *) ibuffer;
+ a.zbuffer_end = (uint8 *) ibuffer + ilen;
+ if (do_zlib(&a, obuffer, olen, 0, 1))
+ return (int) (a.zout - a.zout_start);
+ else
+ return -1;
+}
+
+char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
+{
+ zbuf a;
+ char *p = (char *) malloc(16384);
+ if (p == NULL) return NULL;
+ a.zbuffer = (uint8 *) buffer;
+ a.zbuffer_end = (uint8 *) buffer+len;
+ if (do_zlib(&a, p, 16384, 1, 0)) {
+ if (outlen) *outlen = (int) (a.zout - a.zout_start);
+ return a.zout_start;
+ } else {
+ free(a.zout_start);
+ return NULL;
+ }
+}
+
+int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
+{
+ zbuf a;
+ a.zbuffer = (uint8 *) ibuffer;
+ a.zbuffer_end = (uint8 *) ibuffer + ilen;
+ if (do_zlib(&a, obuffer, olen, 0, 0))
+ return (int) (a.zout - a.zout_start);
+ else
+ return -1;
+}
+
+// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18
+// simple implementation
+// - only 8-bit samples
+// - no CRC checking
+// - allocates lots of intermediate memory
+// - avoids problem of streaming data between subsystems
+// - avoids explicit window management
+// performance
+// - uses stb_zlib, a PD zlib implementation with fast huffman decoding
+
+
+typedef struct
+{
+ uint32 length;
+ uint32 type;
+} chunk;
+
+#define PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
+
+static chunk get_chunk_header(stbi *s)
+{
+ chunk c;
+ c.length = get32(s);
+ c.type = get32(s);
+ return c;
+}
+
+static int check_png_header(stbi *s)
+{
+ static uint8 png_sig[8] = { 137,80,78,71,13,10,26,10 };
+ int i;
+ for (i=0; i < 8; ++i)
+ if (get8u(s) != png_sig[i]) return e("bad png sig","Not a PNG");
+ return 1;
+}
+
+typedef struct
+{
+ stbi *s;
+ uint8 *idata, *expanded, *out;
+} png;
+
+
+enum {
+ F_none=0, F_sub=1, F_up=2, F_avg=3, F_paeth=4,
+ F_avg_first, F_paeth_first
+};
+
+static uint8 first_row_filter[5] =
+{
+ F_none, F_sub, F_none, F_avg_first, F_paeth_first
+};
+
+static int paeth(int a, int b, int c)
+{
+ int p = a + b - c;
+ int pa = abs(p-a);
+ int pb = abs(p-b);
+ int pc = abs(p-c);
+ if (pa <= pb && pa <= pc) return a;
+ if (pb <= pc) return b;
+ return c;
+}
+
+// create the png data from post-deflated data
+static int create_png_image_raw(png *a, uint8 *raw, uint32 raw_len, int out_n, uint32 x, uint32 y)
+{
+ stbi *s = a->s;
+ uint32 i,j,stride = x*out_n;
+ int k;
+ int img_n = s->img_n; // copy it into a local for later
+ assert(out_n == s->img_n || out_n == s->img_n+1);
+ if (stbi_png_partial) y = 1;
+ a->out = (uint8 *) malloc(x * y * out_n);
+ if (!a->out) return e("outofmem", "Out of memory");
+ if (!stbi_png_partial) {
+ if (s->img_x == x && s->img_y == y) {
+ if (raw_len != (img_n * x + 1) * y) return e("not enough pixels","Corrupt PNG");
+ } else { // interlaced:
+ if (raw_len < (img_n * x + 1) * y) return e("not enough pixels","Corrupt PNG");
+ }
+ }
+ for (j=0; j < y; ++j) {
+ uint8 *cur = a->out + stride*j;
+ uint8 *prior = cur - stride;
+ int filter = *raw++;
+ if (filter > 4) return e("invalid filter","Corrupt PNG");
+ // if first row, use special filter that doesn't sample previous row
+ if (j == 0) filter = first_row_filter[filter];
+ // handle first pixel explicitly
+ for (k=0; k < img_n; ++k) {
+ switch (filter) {
+ case F_none : cur[k] = raw[k]; break;
+ case F_sub : cur[k] = raw[k]; break;
+ case F_up : cur[k] = raw[k] + prior[k]; break;
+ case F_avg : cur[k] = raw[k] + (prior[k]>>1); break;
+ case F_paeth : cur[k] = (uint8) (raw[k] + paeth(0,prior[k],0)); break;
+ case F_avg_first : cur[k] = raw[k]; break;
+ case F_paeth_first: cur[k] = raw[k]; break;
+ }
+ }
+ if (img_n != out_n) cur[img_n] = 255;
+ raw += img_n;
+ cur += out_n;
+ prior += out_n;
+ // this is a little gross, so that we don't switch per-pixel or per-component
+ if (img_n == out_n) {
+ #define CASE(f) \
+ case f: \
+ for (i=x-1; i >= 1; --i, raw+=img_n,cur+=img_n,prior+=img_n) \
+ for (k=0; k < img_n; ++k)
+ switch (filter) {
+ CASE(F_none) cur[k] = raw[k]; break;
+ CASE(F_sub) cur[k] = raw[k] + cur[k-img_n]; break;
+ CASE(F_up) cur[k] = raw[k] + prior[k]; break;
+ CASE(F_avg) cur[k] = raw[k] + ((prior[k] + cur[k-img_n])>>1); break;
+ CASE(F_paeth) cur[k] = (uint8) (raw[k] + paeth(cur[k-img_n],prior[k],prior[k-img_n])); break;
+ CASE(F_avg_first) cur[k] = raw[k] + (cur[k-img_n] >> 1); break;
+ CASE(F_paeth_first) cur[k] = (uint8) (raw[k] + paeth(cur[k-img_n],0,0)); break;
+ }
+ #undef CASE
+ } else {
+ assert(img_n+1 == out_n);
+ #define CASE(f) \
+ case f: \
+ for (i=x-1; i >= 1; --i, cur[img_n]=255,raw+=img_n,cur+=out_n,prior+=out_n) \
+ for (k=0; k < img_n; ++k)
+ switch (filter) {
+ CASE(F_none) cur[k] = raw[k]; break;
+ CASE(F_sub) cur[k] = raw[k] + cur[k-out_n]; break;
+ CASE(F_up) cur[k] = raw[k] + prior[k]; break;
+ CASE(F_avg) cur[k] = raw[k] + ((prior[k] + cur[k-out_n])>>1); break;
+ CASE(F_paeth) cur[k] = (uint8) (raw[k] + paeth(cur[k-out_n],prior[k],prior[k-out_n])); break;
+ CASE(F_avg_first) cur[k] = raw[k] + (cur[k-out_n] >> 1); break;
+ CASE(F_paeth_first) cur[k] = (uint8) (raw[k] + paeth(cur[k-out_n],0,0)); break;
+ }
+ #undef CASE
+ }
+ }
+ return 1;
+}
+
+static int create_png_image(png *a, uint8 *raw, uint32 raw_len, int out_n, int interlaced)
+{
+ uint8 *final;
+ int p;
+ int save;
+ if (!interlaced)
+ return create_png_image_raw(a, raw, raw_len, out_n, a->s->img_x, a->s->img_y);
+ save = stbi_png_partial;
+ stbi_png_partial = 0;
+
+ // de-interlacing
+ final = (uint8 *) malloc(a->s->img_x * a->s->img_y * out_n);
+ for (p=0; p < 7; ++p) {
+ int xorig[] = { 0,4,0,2,0,1,0 };
+ int yorig[] = { 0,0,4,0,2,0,1 };
+ int xspc[] = { 8,8,4,4,2,2,1 };
+ int yspc[] = { 8,8,8,4,4,2,2 };
+ int i,j,x,y;
+ // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
+ x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
+ y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
+ if (x && y) {
+ if (!create_png_image_raw(a, raw, raw_len, out_n, x, y)) {
+ free(final);
+ return 0;
+ }
+ for (j=0; j < y; ++j)
+ for (i=0; i < x; ++i)
+ memcpy(final + (j*yspc[p]+yorig[p])*a->s->img_x*out_n + (i*xspc[p]+xorig[p])*out_n,
+ a->out + (j*x+i)*out_n, out_n);
+ free(a->out);
+ raw += (x*out_n+1)*y;
+ raw_len -= (x*out_n+1)*y;
+ }
+ }
+ a->out = final;
+
+ stbi_png_partial = save;
+ return 1;
+}
+
+static int compute_transparency(png *z, uint8 tc[3], int out_n)
+{
+ stbi *s = z->s;
+ uint32 i, pixel_count = s->img_x * s->img_y;
+ uint8 *p = z->out;
+
+ // compute color-based transparency, assuming we've
+ // already got 255 as the alpha value in the output
+ assert(out_n == 2 || out_n == 4);
+
+ if (out_n == 2) {
+ for (i=0; i < pixel_count; ++i) {
+ p[1] = (p[0] == tc[0] ? 0 : 255);
+ p += 2;
+ }
+ } else {
+ for (i=0; i < pixel_count; ++i) {
+ if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+ p[3] = 0;
+ p += 4;
+ }
+ }
+ return 1;
+}
+
+static int expand_palette(png *a, uint8 *palette, int len, int pal_img_n)
+{
+ uint32 i, pixel_count = a->s->img_x * a->s->img_y;
+ uint8 *p, *temp_out, *orig = a->out;
+
+ p = (uint8 *) malloc(pixel_count * pal_img_n);
+ if (p == NULL) return e("outofmem", "Out of memory");
+
+ // between here and free(out) below, exitting would leak
+ temp_out = p;
+
+ if (pal_img_n == 3) {
+ for (i=0; i < pixel_count; ++i) {
+ int n = orig[i]*4;
+ p[0] = palette[n ];
+ p[1] = palette[n+1];
+ p[2] = palette[n+2];
+ p += 3;
+ }
+ } else {
+ for (i=0; i < pixel_count; ++i) {
+ int n = orig[i]*4;
+ p[0] = palette[n ];
+ p[1] = palette[n+1];
+ p[2] = palette[n+2];
+ p[3] = palette[n+3];
+ p += 4;
+ }
+ }
+ free(a->out);
+ a->out = temp_out;
+
+ STBI_NOTUSED(len);
+
+ return 1;
+}
+
+static int stbi_unpremultiply_on_load = 0;
+static int stbi_de_iphone_flag = 0;
+
+void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
+{
+ stbi_unpremultiply_on_load = flag_true_if_should_unpremultiply;
+}
+void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
+{
+ stbi_de_iphone_flag = flag_true_if_should_convert;
+}
+
+static void stbi_de_iphone(png *z)
+{
+ stbi *s = z->s;
+ uint32 i, pixel_count = s->img_x * s->img_y;
+ uint8 *p = z->out;
+
+ if (s->img_out_n == 3) { // convert bgr to rgb
+ for (i=0; i < pixel_count; ++i) {
+ uint8 t = p[0];
+ p[0] = p[2];
+ p[2] = t;
+ p += 3;
+ }
+ } else {
+ assert(s->img_out_n == 4);
+ if (stbi_unpremultiply_on_load) {
+ // convert bgr to rgb and unpremultiply
+ for (i=0; i < pixel_count; ++i) {
+ uint8 a = p[3];
+ uint8 t = p[0];
+ if (a) {
+ p[0] = p[2] * 255 / a;
+ p[1] = p[1] * 255 / a;
+ p[2] = t * 255 / a;
+ } else {
+ p[0] = p[2];
+ p[2] = t;
+ }
+ p += 4;
+ }
+ } else {
+ // convert bgr to rgb
+ for (i=0; i < pixel_count; ++i) {
+ uint8 t = p[0];
+ p[0] = p[2];
+ p[2] = t;
+ p += 4;
+ }
+ }
+ }
+}
+
+static int parse_png_file(png *z, int scan, int req_comp)
+{
+ uint8 palette[1024], pal_img_n=0;
+ uint8 has_trans=0, tc[3];
+ uint32 ioff=0, idata_limit=0, i, pal_len=0;
+ int first=1,k,interlace=0, iphone=0;
+ stbi *s = z->s;
+
+ z->expanded = NULL;
+ z->idata = NULL;
+ z->out = NULL;
+
+ if (!check_png_header(s)) return 0;
+
+ if (scan == SCAN_type) return 1;
+
+ for (;;) {
+ chunk c = get_chunk_header(s);
+ switch (c.type) {
+ case PNG_TYPE('C','g','B','I'):
+ iphone = stbi_de_iphone_flag;
+ skip(s, c.length);
+ break;
+ case PNG_TYPE('I','H','D','R'): {
+ int depth,color,comp,filter;
+ if (!first) return e("multiple IHDR","Corrupt PNG");
+ first = 0;
+ if (c.length != 13) return e("bad IHDR len","Corrupt PNG");
+ s->img_x = get32(s); if (s->img_x > (1 << 24)) return e("too large","Very large image (corrupt?)");
+ s->img_y = get32(s); if (s->img_y > (1 << 24)) return e("too large","Very large image (corrupt?)");
+ depth = get8(s); if (depth != 8) return e("8bit only","PNG not supported: 8-bit only");
+ color = get8(s); if (color > 6) return e("bad ctype","Corrupt PNG");
+ if (color == 3) pal_img_n = 3; else if (color & 1) return e("bad ctype","Corrupt PNG");
+ comp = get8(s); if (comp) return e("bad comp method","Corrupt PNG");
+ filter= get8(s); if (filter) return e("bad filter method","Corrupt PNG");
+ interlace = get8(s); if (interlace>1) return e("bad interlace method","Corrupt PNG");
+ if (!s->img_x || !s->img_y) return e("0-pixel image","Corrupt PNG");
+ if (!pal_img_n) {
+ s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
+ if ((1 << 30) / s->img_x / s->img_n < s->img_y) return e("too large", "Image too large to decode");
+ if (scan == SCAN_header) return 1;
+ } else {
+ // if paletted, then pal_n is our final components, and
+ // img_n is # components to decompress/filter.
+ s->img_n = 1;
+ if ((1 << 30) / s->img_x / 4 < s->img_y) return e("too large","Corrupt PNG");
+ // if SCAN_header, have to scan to see if we have a tRNS
+ }
+ break;
+ }
+
+ case PNG_TYPE('P','L','T','E'): {
+ if (first) return e("first not IHDR", "Corrupt PNG");
+ if (c.length > 256*3) return e("invalid PLTE","Corrupt PNG");
+ pal_len = c.length / 3;
+ if (pal_len * 3 != c.length) return e("invalid PLTE","Corrupt PNG");
+ for (i=0; i < pal_len; ++i) {
+ palette[i*4+0] = get8u(s);
+ palette[i*4+1] = get8u(s);
+ palette[i*4+2] = get8u(s);
+ palette[i*4+3] = 255;
+ }
+ break;
+ }
+
+ case PNG_TYPE('t','R','N','S'): {
+ if (first) return e("first not IHDR", "Corrupt PNG");
+ if (z->idata) return e("tRNS after IDAT","Corrupt PNG");
+ if (pal_img_n) {
+ if (scan == SCAN_header) { s->img_n = 4; return 1; }
+ if (pal_len == 0) return e("tRNS before PLTE","Corrupt PNG");
+ if (c.length > pal_len) return e("bad tRNS len","Corrupt PNG");
+ pal_img_n = 4;
+ for (i=0; i < c.length; ++i)
+ palette[i*4+3] = get8u(s);
+ } else {
+ if (!(s->img_n & 1)) return e("tRNS with alpha","Corrupt PNG");
+ if (c.length != (uint32) s->img_n*2) return e("bad tRNS len","Corrupt PNG");
+ has_trans = 1;
+ for (k=0; k < s->img_n; ++k)
+ tc[k] = (uint8) get16(s); // non 8-bit images will be larger
+ }
+ break;
+ }
+
+ case PNG_TYPE('I','D','A','T'): {
+ if (first) return e("first not IHDR", "Corrupt PNG");
+ if (pal_img_n && !pal_len) return e("no PLTE","Corrupt PNG");
+ if (scan == SCAN_header) { s->img_n = pal_img_n; return 1; }
+ if (ioff + c.length > idata_limit) {
+ uint8 *p;
+ if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
+ while (ioff + c.length > idata_limit)
+ idata_limit *= 2;
+ p = (uint8 *) realloc(z->idata, idata_limit); if (p == NULL) return e("outofmem", "Out of memory");
+ z->idata = p;
+ }
+ if (!getn(s, z->idata+ioff,c.length)) return e("outofdata","Corrupt PNG");
+ ioff += c.length;
+ break;
+ }
+
+ case PNG_TYPE('I','E','N','D'): {
+ uint32 raw_len;
+ if (first) return e("first not IHDR", "Corrupt PNG");
+ if (scan != SCAN_load) return 1;
+ if (z->idata == NULL) return e("no IDAT","Corrupt PNG");
+ z->expanded = (uint8 *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, 16384, (int *) &raw_len, !iphone);
+ if (z->expanded == NULL) return 0; // zlib should set error
+ free(z->idata); z->idata = NULL;
+ if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
+ s->img_out_n = s->img_n+1;
+ else
+ s->img_out_n = s->img_n;
+ if (!create_png_image(z, z->expanded, raw_len, s->img_out_n, interlace)) return 0;
+ if (has_trans)
+ if (!compute_transparency(z, tc, s->img_out_n)) return 0;
+ if (iphone && s->img_out_n > 2)
+ stbi_de_iphone(z);
+ if (pal_img_n) {
+ // pal_img_n == 3 or 4
+ s->img_n = pal_img_n; // record the actual colors we had
+ s->img_out_n = pal_img_n;
+ if (req_comp >= 3) s->img_out_n = req_comp;
+ if (!expand_palette(z, palette, pal_len, s->img_out_n))
+ return 0;
+ }
+ free(z->expanded); z->expanded = NULL;
+ return 1;
+ }
+
+ default:
+ // if critical, fail
+ if (first) return e("first not IHDR", "Corrupt PNG");
+ if ((c.type & (1 << 29)) == 0) {
+ #ifndef STBI_NO_FAILURE_STRINGS
+ // not threadsafe
+ static char invalid_chunk[] = "XXXX chunk not known";
+ invalid_chunk[0] = (uint8) (c.type >> 24);
+ invalid_chunk[1] = (uint8) (c.type >> 16);
+ invalid_chunk[2] = (uint8) (c.type >> 8);
+ invalid_chunk[3] = (uint8) (c.type >> 0);
+ #endif
+ return e(invalid_chunk, "PNG not supported: unknown chunk type");
+ }
+ skip(s, c.length);
+ break;
+ }
+ // end of chunk, read and skip CRC
+ get32(s);
+ }
+}
+
+static unsigned char *do_png(png *p, int *x, int *y, int *n, int req_comp)
+{
+ unsigned char *result=NULL;
+ if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error");
+ if (parse_png_file(p, SCAN_load, req_comp)) {
+ result = p->out;
+ p->out = NULL;
+ if (req_comp && req_comp != p->s->img_out_n) {
+ result = convert_format(result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+ p->s->img_out_n = req_comp;
+ if (result == NULL) return result;
+ }
+ *x = p->s->img_x;
+ *y = p->s->img_y;
+ if (n) *n = p->s->img_n;
+ }
+ free(p->out); p->out = NULL;
+ free(p->expanded); p->expanded = NULL;
+ free(p->idata); p->idata = NULL;
+
+ return result;
+}
+
+static unsigned char *stbi_png_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+ png p;
+ p.s = s;
+ return do_png(&p, x,y,comp,req_comp);
+}
+
+static int stbi_png_test(stbi *s)
+{
+ int r;
+ r = check_png_header(s);
+ stbi_rewind(s);
+ return r;
+}
+
+static int stbi_png_info_raw(png *p, int *x, int *y, int *comp)
+{
+ if (!parse_png_file(p, SCAN_header, 0)) {
+ stbi_rewind( p->s );
+ return 0;
+ }
+ if (x) *x = p->s->img_x;
+ if (y) *y = p->s->img_y;
+ if (comp) *comp = p->s->img_n;
+ return 1;
+}
+
+static int stbi_png_info(stbi *s, int *x, int *y, int *comp)
+{
+ png p;
+ p.s = s;
+ return stbi_png_info_raw(&p, x, y, comp);
+}
+
+// Microsoft/Windows BMP image
+
+static int bmp_test(stbi *s)
+{
+ int sz;
+ if (get8(s) != 'B') return 0;
+ if (get8(s) != 'M') return 0;
+ get32le(s); // discard filesize
+ get16le(s); // discard reserved
+ get16le(s); // discard reserved
+ get32le(s); // discard data offset
+ sz = get32le(s);
+ if (sz == 12 || sz == 40 || sz == 56 || sz == 108) return 1;
+ return 0;
+}
+
+static int stbi_bmp_test(stbi *s)
+{
+ int r = bmp_test(s);
+ stbi_rewind(s);
+ return r;
+}
+
+
+// returns 0..31 for the highest set bit
+static int high_bit(unsigned int z)
+{
+ int n=0;
+ if (z == 0) return -1;
+ if (z >= 0x10000) n += 16, z >>= 16;
+ if (z >= 0x00100) n += 8, z >>= 8;
+ if (z >= 0x00010) n += 4, z >>= 4;
+ if (z >= 0x00004) n += 2, z >>= 2;
+ if (z >= 0x00002) n += 1, z >>= 1;
+ return n;
+}
+
+static int bitcount(unsigned int a)
+{
+ a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2
+ a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4
+ a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
+ a = (a + (a >> 8)); // max 16 per 8 bits
+ a = (a + (a >> 16)); // max 32 per 8 bits
+ return a & 0xff;
+}
+
+static int shiftsigned(int v, int shift, int bits)
+{
+ int result;
+ int z=0;
+
+ if (shift < 0) v <<= -shift;
+ else v >>= shift;
+ result = v;
+
+ z = bits;
+ while (z < 8) {
+ result += v >> z;
+ z += bits;
+ }
+ return result;
+}
+
+static stbi_uc *bmp_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+ uint8 *out;
+ unsigned int mr=0,mg=0,mb=0,ma=0, fake_a=0;
+ stbi_uc pal[256][4];
+ int psize=0,i,j,compress=0,width;
+ int bpp, flip_vertically, pad, target, offset, hsz;
+ if (get8(s) != 'B' || get8(s) != 'M') return epuc("not BMP", "Corrupt BMP");
+ get32le(s); // discard filesize
+ get16le(s); // discard reserved
+ get16le(s); // discard reserved
+ offset = get32le(s);
+ hsz = get32le(s);
+ if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108) return epuc("unknown BMP", "BMP type not supported: unknown");
+ if (hsz == 12) {
+ s->img_x = get16le(s);
+ s->img_y = get16le(s);
+ } else {
+ s->img_x = get32le(s);
+ s->img_y = get32le(s);
+ }
+ if (get16le(s) != 1) return epuc("bad BMP", "bad BMP");
+ bpp = get16le(s);
+ if (bpp == 1) return epuc("monochrome", "BMP type not supported: 1-bit");
+ flip_vertically = ((int) s->img_y) > 0;
+ s->img_y = abs((int) s->img_y);
+ if (hsz == 12) {
+ if (bpp < 24)
+ psize = (offset - 14 - 24) / 3;
+ } else {
+ compress = get32le(s);
+ if (compress == 1 || compress == 2) return epuc("BMP RLE", "BMP type not supported: RLE");
+ get32le(s); // discard sizeof
+ get32le(s); // discard hres
+ get32le(s); // discard vres
+ get32le(s); // discard colorsused
+ get32le(s); // discard max important
+ if (hsz == 40 || hsz == 56) {
+ if (hsz == 56) {
+ get32le(s);
+ get32le(s);
+ get32le(s);
+ get32le(s);
+ }
+ if (bpp == 16 || bpp == 32) {
+ mr = mg = mb = 0;
+ if (compress == 0) {
+ if (bpp == 32) {
+ mr = 0xffu << 16;
+ mg = 0xffu << 8;
+ mb = 0xffu << 0;
+ ma = 0xffu << 24;
+ fake_a = 1; // @TODO: check for cases like alpha value is all 0 and switch it to 255
+ } else {
+ mr = 31u << 10;
+ mg = 31u << 5;
+ mb = 31u << 0;
+ }
+ } else if (compress == 3) {
+ mr = get32le(s);
+ mg = get32le(s);
+ mb = get32le(s);
+ // not documented, but generated by photoshop and handled by mspaint
+ if (mr == mg && mg == mb) {
+ // ?!?!?
+ return epuc("bad BMP", "bad BMP");
+ }
+ } else
+ return epuc("bad BMP", "bad BMP");
+ }
+ } else {
+ assert(hsz == 108);
+ mr = get32le(s);
+ mg = get32le(s);
+ mb = get32le(s);
+ ma = get32le(s);
+ get32le(s); // discard color space
+ for (i=0; i < 12; ++i)
+ get32le(s); // discard color space parameters
+ }
+ if (bpp < 16)
+ psize = (offset - 14 - hsz) >> 2;
+ }
+ s->img_n = ma ? 4 : 3;
+ if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
+ target = req_comp;
+ else
+ target = s->img_n; // if they want monochrome, we'll post-convert
+ out = (stbi_uc *) malloc(target * s->img_x * s->img_y);
+ if (!out) return epuc("outofmem", "Out of memory");
+ if (bpp < 16) {
+ int z=0;
+ if (psize == 0 || psize > 256) { free(out); return epuc("invalid", "Corrupt BMP"); }
+ for (i=0; i < psize; ++i) {
+ pal[i][2] = get8u(s);
+ pal[i][1] = get8u(s);
+ pal[i][0] = get8u(s);
+ if (hsz != 12) get8(s);
+ pal[i][3] = 255;
+ }
+ skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4));
+ if (bpp == 4) width = (s->img_x + 1) >> 1;
+ else if (bpp == 8) width = s->img_x;
+ else { free(out); return epuc("bad bpp", "Corrupt BMP"); }
+ pad = (-width)&3;
+ for (j=0; j < (int) s->img_y; ++j) {
+ for (i=0; i < (int) s->img_x; i += 2) {
+ int v=get8(s),v2=0;
+ if (bpp == 4) {
+ v2 = v & 15;
+ v >>= 4;
+ }
+ out[z++] = pal[v][0];
+ out[z++] = pal[v][1];
+ out[z++] = pal[v][2];
+ if (target == 4) out[z++] = 255;
+ if (i+1 == (int) s->img_x) break;
+ v = (bpp == 8) ? get8(s) : v2;
+ out[z++] = pal[v][0];
+ out[z++] = pal[v][1];
+ out[z++] = pal[v][2];
+ if (target == 4) out[z++] = 255;
+ }
+ skip(s, pad);
+ }
+ } else {
+ int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
+ int z = 0;
+ int easy=0;
+ skip(s, offset - 14 - hsz);
+ if (bpp == 24) width = 3 * s->img_x;
+ else if (bpp == 16) width = 2*s->img_x;
+ else /* bpp = 32 and pad = 0 */ width=0;
+ pad = (-width) & 3;
+ if (bpp == 24) {
+ easy = 1;
+ } else if (bpp == 32) {
+ if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
+ easy = 2;
+ }
+ if (!easy) {
+ if (!mr || !mg || !mb) { free(out); return epuc("bad masks", "Corrupt BMP"); }
+ // right shift amt to put high bit in position #7
+ rshift = high_bit(mr)-7; rcount = bitcount(mr);
+ gshift = high_bit(mg)-7; gcount = bitcount(mr);
+ bshift = high_bit(mb)-7; bcount = bitcount(mr);
+ ashift = high_bit(ma)-7; acount = bitcount(mr);
+ }
+ for (j=0; j < (int) s->img_y; ++j) {
+ if (easy) {
+ for (i=0; i < (int) s->img_x; ++i) {
+ int a;
+ out[z+2] = get8u(s);
+ out[z+1] = get8u(s);
+ out[z+0] = get8u(s);
+ z += 3;
+ a = (easy == 2 ? get8(s) : 255);
+ if (target == 4) out[z++] = (uint8) a;
+ }
+ } else {
+ for (i=0; i < (int) s->img_x; ++i) {
+ uint32 v = (bpp == 16 ? get16le(s) : get32le(s));
+ int a;
+ out[z++] = (uint8) shiftsigned(v & mr, rshift, rcount);
+ out[z++] = (uint8) shiftsigned(v & mg, gshift, gcount);
+ out[z++] = (uint8) shiftsigned(v & mb, bshift, bcount);
+ a = (ma ? shiftsigned(v & ma, ashift, acount) : 255);
+ if (target == 4) out[z++] = (uint8) a;
+ }
+ }
+ skip(s, pad);
+ }
+ }
+ if (flip_vertically) {
+ stbi_uc t;
+ for (j=0; j < (int) s->img_y>>1; ++j) {
+ stbi_uc *p1 = out + j *s->img_x*target;
+ stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
+ for (i=0; i < (int) s->img_x*target; ++i) {
+ t = p1[i], p1[i] = p2[i], p2[i] = t;
+ }
+ }
+ }
+
+ if (req_comp && req_comp != target) {
+ out = convert_format(out, target, req_comp, s->img_x, s->img_y);
+ if (out == NULL) return out; // convert_format frees input on failure
+ }
+
+ *x = s->img_x;
+ *y = s->img_y;
+ if (comp) *comp = s->img_n;
+ return out;
+
+ NVG_NOTUSED(fake_a);
+}
+
+static stbi_uc *stbi_bmp_load(stbi *s,int *x, int *y, int *comp, int req_comp)
+{
+ return bmp_load(s, x,y,comp,req_comp);
+}
+
+
+// Targa Truevision - TGA
+// by Jonathan Dummer
+
+static int tga_info(stbi *s, int *x, int *y, int *comp)
+{
+ int tga_w, tga_h, tga_comp;
+ int sz;
+ get8u(s); // discard Offset
+ sz = get8u(s); // color type
+ if( sz > 1 ) {
+ stbi_rewind(s);
+ return 0; // only RGB or indexed allowed
+ }
+ sz = get8u(s); // image type
+ // only RGB or grey allowed, +/- RLE
+ if ((sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11)) return 0;
+ skip(s,9);
+ tga_w = get16le(s);
+ if( tga_w < 1 ) {
+ stbi_rewind(s);
+ return 0; // test width
+ }
+ tga_h = get16le(s);
+ if( tga_h < 1 ) {
+ stbi_rewind(s);
+ return 0; // test height
+ }
+ sz = get8(s); // bits per pixel
+ // only RGB or RGBA or grey allowed
+ if ((sz != 8) && (sz != 16) && (sz != 24) && (sz != 32)) {
+ stbi_rewind(s);
+ return 0;
+ }
+ tga_comp = sz;
+ if (x) *x = tga_w;
+ if (y) *y = tga_h;
+ if (comp) *comp = tga_comp / 8;
+ return 1; // seems to have passed everything
+}
+
+int stbi_tga_info(stbi *s, int *x, int *y, int *comp)
+{
+ return tga_info(s, x, y, comp);
+}
+
+static int tga_test(stbi *s)
+{
+ int sz;
+ get8u(s); // discard Offset
+ sz = get8u(s); // color type
+ if ( sz > 1 ) return 0; // only RGB or indexed allowed
+ sz = get8u(s); // image type
+ if ( (sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11) ) return 0; // only RGB or grey allowed, +/- RLE
+ get16(s); // discard palette start
+ get16(s); // discard palette length
+ get8(s); // discard bits per palette color entry
+ get16(s); // discard x origin
+ get16(s); // discard y origin
+ if ( get16(s) < 1 ) return 0; // test width
+ if ( get16(s) < 1 ) return 0; // test height
+ sz = get8(s); // bits per pixel
+ if ( (sz != 8) && (sz != 16) && (sz != 24) && (sz != 32) ) return 0; // only RGB or RGBA or grey allowed
+ return 1; // seems to have passed everything
+}
+
+static int stbi_tga_test(stbi *s)
+{
+ int res = tga_test(s);
+ stbi_rewind(s);
+ return res;
+}
+
+static stbi_uc *tga_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+ // read in the TGA header stuff
+ int tga_offset = get8u(s);
+ int tga_indexed = get8u(s);
+ int tga_image_type = get8u(s);
+ int tga_is_RLE = 0;
+ int tga_palette_start = get16le(s);
+ int tga_palette_len = get16le(s);
+ int tga_palette_bits = get8u(s);
+ int tga_x_origin = get16le(s);
+ int tga_y_origin = get16le(s);
+ int tga_width = get16le(s);
+ int tga_height = get16le(s);
+ int tga_bits_per_pixel = get8u(s);
+ int tga_inverted = get8u(s);
+ // image data
+ unsigned char *tga_data;
+ unsigned char *tga_palette = NULL;
+ int i, j;
+ unsigned char raw_data[4];
+ unsigned char trans_data[4];
+ int RLE_count = 0;
+ int RLE_repeating = 0;
+ int read_next_pixel = 1;
+
+ // do a tiny bit of precessing
+ if ( tga_image_type >= 8 )
+ {
+ tga_image_type -= 8;
+ tga_is_RLE = 1;
+ }
+ /* int tga_alpha_bits = tga_inverted & 15; */
+ tga_inverted = 1 - ((tga_inverted >> 5) & 1);
+
+ // error check
+ if ( //(tga_indexed) ||
+ (tga_width < 1) || (tga_height < 1) ||
+ (tga_image_type < 1) || (tga_image_type > 3) ||
+ ((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16) &&
+ (tga_bits_per_pixel != 24) && (tga_bits_per_pixel != 32))
+ )
+ {
+ return NULL; // we don't report this as a bad TGA because we don't even know if it's TGA
+ }
+
+ // If I'm paletted, then I'll use the number of bits from the palette
+ if ( tga_indexed )
+ {
+ tga_bits_per_pixel = tga_palette_bits;
+ }
+
+ // tga info
+ *x = tga_width;
+ *y = tga_height;
+ if ( (req_comp < 1) || (req_comp > 4) )
+ {
+ // just use whatever the file was
+ req_comp = tga_bits_per_pixel / 8;
+ *comp = req_comp;
+ } else
+ {
+ // force a new number of components
+ *comp = tga_bits_per_pixel/8;
+ }
+ tga_data = (unsigned char*)malloc( tga_width * tga_height * req_comp );
+ if (!tga_data) return epuc("outofmem", "Out of memory");
+
+ // skip to the data's starting position (offset usually = 0)
+ skip(s, tga_offset );
+ // do I need to load a palette?
+ if ( tga_indexed )
+ {
+ // any data to skip? (offset usually = 0)
+ skip(s, tga_palette_start );
+ // load the palette
+ tga_palette = (unsigned char*)malloc( tga_palette_len * tga_palette_bits / 8 );
+ if (!tga_palette) return epuc("outofmem", "Out of memory");
+ if (!getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 )) {
+ free(tga_data);
+ free(tga_palette);
+ return epuc("bad palette", "Corrupt TGA");
+ }
+ }
+ // load the data
+ trans_data[0] = trans_data[1] = trans_data[2] = trans_data[3] = 0;
+ for (i=0; i < tga_width * tga_height; ++i)
+ {
+ // if I'm in RLE mode, do I need to get a RLE chunk?
+ if ( tga_is_RLE )
+ {
+ if ( RLE_count == 0 )
+ {
+ // yep, get the next byte as a RLE command
+ int RLE_cmd = get8u(s);
+ RLE_count = 1 + (RLE_cmd & 127);
+ RLE_repeating = RLE_cmd >> 7;
+ read_next_pixel = 1;
+ } else if ( !RLE_repeating )
+ {
+ read_next_pixel = 1;
+ }
+ } else
+ {
+ read_next_pixel = 1;
+ }
+ // OK, if I need to read a pixel, do it now
+ if ( read_next_pixel )
+ {
+ // load however much data we did have
+ if ( tga_indexed )
+ {
+ // read in 1 byte, then perform the lookup
+ int pal_idx = get8u(s);
+ if ( pal_idx >= tga_palette_len )
+ {
+ // invalid index
+ pal_idx = 0;
+ }
+ pal_idx *= tga_bits_per_pixel / 8;
+ for (j = 0; j*8 < tga_bits_per_pixel; ++j)
+ {
+ raw_data[j] = tga_palette[pal_idx+j];
+ }
+ } else
+ {
+ // read in the data raw
+ for (j = 0; j*8 < tga_bits_per_pixel; ++j)
+ {
+ raw_data[j] = get8u(s);
+ }
+ }
+ // convert raw to the intermediate format
+ switch (tga_bits_per_pixel)
+ {
+ case 8:
+ // Luminous => RGBA
+ trans_data[0] = raw_data[0];
+ trans_data[1] = raw_data[0];
+ trans_data[2] = raw_data[0];
+ trans_data[3] = 255;
+ break;
+ case 16:
+ // Luminous,Alpha => RGBA
+ trans_data[0] = raw_data[0];
+ trans_data[1] = raw_data[0];
+ trans_data[2] = raw_data[0];
+ trans_data[3] = raw_data[1];
+ break;
+ case 24:
+ // BGR => RGBA
+ trans_data[0] = raw_data[2];
+ trans_data[1] = raw_data[1];
+ trans_data[2] = raw_data[0];
+ trans_data[3] = 255;
+ break;
+ case 32:
+ // BGRA => RGBA
+ trans_data[0] = raw_data[2];
+ trans_data[1] = raw_data[1];
+ trans_data[2] = raw_data[0];
+ trans_data[3] = raw_data[3];
+ break;
+ }
+ // clear the reading flag for the next pixel
+ read_next_pixel = 0;
+ } // end of reading a pixel
+ // convert to final format
+ switch (req_comp)
+ {
+ case 1:
+ // RGBA => Luminance
+ tga_data[i*req_comp+0] = compute_y(trans_data[0],trans_data[1],trans_data[2]);
+ break;
+ case 2:
+ // RGBA => Luminance,Alpha
+ tga_data[i*req_comp+0] = compute_y(trans_data[0],trans_data[1],trans_data[2]);
+ tga_data[i*req_comp+1] = trans_data[3];
+ break;
+ case 3:
+ // RGBA => RGB
+ tga_data[i*req_comp+0] = trans_data[0];
+ tga_data[i*req_comp+1] = trans_data[1];
+ tga_data[i*req_comp+2] = trans_data[2];
+ break;
+ case 4:
+ // RGBA => RGBA
+ tga_data[i*req_comp+0] = trans_data[0];
+ tga_data[i*req_comp+1] = trans_data[1];
+ tga_data[i*req_comp+2] = trans_data[2];
+ tga_data[i*req_comp+3] = trans_data[3];
+ break;
+ }
+ // in case we're in RLE mode, keep counting down
+ --RLE_count;
+ }
+ // do I need to invert the image?
+ if ( tga_inverted )
+ {
+ for (j = 0; j*2 < tga_height; ++j)
+ {
+ int index1 = j * tga_width * req_comp;
+ int index2 = (tga_height - 1 - j) * tga_width * req_comp;
+ for (i = tga_width * req_comp; i > 0; --i)
+ {
+ unsigned char temp = tga_data[index1];
+ tga_data[index1] = tga_data[index2];
+ tga_data[index2] = temp;
+ ++index1;
+ ++index2;
+ }
+ }
+ }
+ // clear my palette, if I had one
+ if ( tga_palette != NULL )
+ {
+ free( tga_palette );
+ }
+ // the things I do to get rid of an error message, and yet keep
+ // Microsoft's C compilers happy... [8^(
+ tga_palette_start = tga_palette_len = tga_palette_bits =
+ tga_x_origin = tga_y_origin = 0;
+ // OK, done
+ return tga_data;
+}
+
+static stbi_uc *stbi_tga_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+ return tga_load(s,x,y,comp,req_comp);
+}
+
+
+// *************************************************************************************************
+// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
+
+static int psd_test(stbi *s)
+{
+ if (get32(s) != 0x38425053) return 0; // "8BPS"
+ else return 1;
+}
+
+static int stbi_psd_test(stbi *s)
+{
+ int r = psd_test(s);
+ stbi_rewind(s);
+ return r;
+}
+
+static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+ int pixelCount;
+ int channelCount, compression;
+ int channel, i, count, len;
+ int w,h;
+ uint8 *out;
+
+ // Check identifier
+ if (get32(s) != 0x38425053) // "8BPS"
+ return epuc("not PSD", "Corrupt PSD image");
+
+ // Check file type version.
+ if (get16(s) != 1)
+ return epuc("wrong version", "Unsupported version of PSD image");
+
+ // Skip 6 reserved bytes.
+ skip(s, 6 );
+
+ // Read the number of channels (R, G, B, A, etc).
+ channelCount = get16(s);
+ if (channelCount < 0 || channelCount > 16)
+ return epuc("wrong channel count", "Unsupported number of channels in PSD image");
+
+ // Read the rows and columns of the image.
+ h = get32(s);
+ w = get32(s);
+
+ // Make sure the depth is 8 bits.
+ if (get16(s) != 8)
+ return epuc("unsupported bit depth", "PSD bit depth is not 8 bit");
+
+ // Make sure the color mode is RGB.
+ // Valid options are:
+ // 0: Bitmap
+ // 1: Grayscale
+ // 2: Indexed color
+ // 3: RGB color
+ // 4: CMYK color
+ // 7: Multichannel
+ // 8: Duotone
+ // 9: Lab color
+ if (get16(s) != 3)
+ return epuc("wrong color format", "PSD is not in RGB color format");
+
+ // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.)
+ skip(s,get32(s) );
+
+ // Skip the image resources. (resolution, pen tool paths, etc)
+ skip(s, get32(s) );
+
+ // Skip the reserved data.
+ skip(s, get32(s) );
+
+ // Find out if the data is compressed.
+ // Known values:
+ // 0: no compression
+ // 1: RLE compressed
+ compression = get16(s);
+ if (compression > 1)
+ return epuc("bad compression", "PSD has an unknown compression format");
+
+ // Create the destination image.
+ out = (stbi_uc *) malloc(4 * w*h);
+ if (!out) return epuc("outofmem", "Out of memory");
+ pixelCount = w*h;
+
+ // Initialize the data to zero.
+ //memset( out, 0, pixelCount * 4 );
+
+ // Finally, the image data.
+ if (compression) {
+ // RLE as used by .PSD and .TIFF
+ // Loop until you get the number of unpacked bytes you are expecting:
+ // Read the next source byte into n.
+ // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
+ // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
+ // Else if n is 128, noop.
+ // Endloop
+
+ // The RLE-compressed data is preceeded by a 2-byte data count for each row in the data,
+ // which we're going to just skip.
+ skip(s, h * channelCount * 2 );
+
+ // Read the RLE data by channel.
+ for (channel = 0; channel < 4; channel++) {
+ uint8 *p;
+
+ p = out+channel;
+ if (channel >= channelCount) {
+ // Fill this channel with default data.
+ for (i = 0; i < pixelCount; i++) *p = (channel == 3 ? 255 : 0), p += 4;
+ } else {
+ // Read the RLE data.
+ count = 0;
+ while (count < pixelCount) {
+ len = get8(s);
+ if (len == 128) {
+ // No-op.
+ } else if (len < 128) {
+ // Copy next len+1 bytes literally.
+ len++;
+ count += len;
+ while (len) {
+ *p = get8u(s);
+ p += 4;
+ len--;
+ }
+ } else if (len > 128) {
+ uint8 val;
+ // Next -len+1 bytes in the dest are replicated from next source byte.
+ // (Interpret len as a negative 8-bit int.)
+ len ^= 0x0FF;
+ len += 2;
+ val = get8u(s);
+ count += len;
+ while (len) {
+ *p = val;
+ p += 4;
+ len--;
+ }
+ }
+ }
+ }
+ }
+
+ } else {
+ // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...)
+ // where each channel consists of an 8-bit value for each pixel in the image.
+
+ // Read the data by channel.
+ for (channel = 0; channel < 4; channel++) {
+ uint8 *p;
+
+ p = out + channel;
+ if (channel > channelCount) {
+ // Fill this channel with default data.
+ for (i = 0; i < pixelCount; i++) *p = channel == 3 ? 255 : 0, p += 4;
+ } else {
+ // Read the data.
+ for (i = 0; i < pixelCount; i++)
+ *p = get8u(s), p += 4;
+ }
+ }
+ }
+
+ if (req_comp && req_comp != 4) {
+ out = convert_format(out, 4, req_comp, w, h);
+ if (out == NULL) return out; // convert_format frees input on failure
+ }
+
+ if (comp) *comp = channelCount;
+ *y = h;
+ *x = w;
+
+ return out;
+}
+
+static stbi_uc *stbi_psd_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+ return psd_load(s,x,y,comp,req_comp);
+}
+
+// *************************************************************************************************
+// Softimage PIC loader
+// by Tom Seddon
+//
+// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
+// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
+
+static int pic_is4(stbi *s,const char *str)
+{
+ int i;
+ for (i=0; i<4; ++i)
+ if (get8(s) != (stbi_uc)str[i])
+ return 0;
+
+ return 1;
+}
+
+static int pic_test(stbi *s)
+{
+ int i;
+
+ if (!pic_is4(s,"\x53\x80\xF6\x34"))
+ return 0;
+
+ for(i=0;i<84;++i)
+ get8(s);
+
+ if (!pic_is4(s,"PICT"))
+ return 0;
+
+ return 1;
+}
+
+typedef struct
+{
+ stbi_uc size,type,channel;
+} pic_packet_t;
+
+static stbi_uc *pic_readval(stbi *s, int channel, stbi_uc *dest)
+{
+ int mask=0x80, i;
+
+ for (i=0; i<4; ++i, mask>>=1) {
+ if (channel & mask) {
+ if (at_eof(s)) return epuc("bad file","PIC file too short");
+ dest[i]=get8u(s);
+ }
+ }
+
+ return dest;
+}
+
+static void pic_copyval(int channel,stbi_uc *dest,const stbi_uc *src)
+{
+ int mask=0x80,i;
+
+ for (i=0;i<4; ++i, mask>>=1)
+ if (channel&mask)
+ dest[i]=src[i];
+}
+
+static stbi_uc *pic_load2(stbi *s,int width,int height,int *comp, stbi_uc *result)
+{
+ int act_comp=0,num_packets=0,y,chained;
+ pic_packet_t packets[10];
+
+ // this will (should...) cater for even some bizarre stuff like having data
+ // for the same channel in multiple packets.
+ do {
+ pic_packet_t *packet;
+
+ if (num_packets==sizeof(packets)/sizeof(packets[0]))
+ return epuc("bad format","too many packets");
+
+ packet = &packets[num_packets++];
+
+ chained = get8(s);
+ packet->size = get8u(s);
+ packet->type = get8u(s);
+ packet->channel = get8u(s);
+
+ act_comp |= packet->channel;
+
+ if (at_eof(s)) return epuc("bad file","file too short (reading packets)");
+ if (packet->size != 8) return epuc("bad format","packet isn't 8bpp");
+ } while (chained);
+
+ *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?
+
+ for(y=0; y<height; ++y) {
+ int packet_idx;
+
+ for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
+ pic_packet_t *packet = &packets[packet_idx];
+ stbi_uc *dest = result+y*width*4;
+
+ switch (packet->type) {
+ default:
+ return epuc("bad format","packet has bad compression type");
+
+ case 0: {//uncompressed
+ int x;
+
+ for(x=0;x<width;++x, dest+=4)
+ if (!pic_readval(s,packet->channel,dest))
+ return 0;
+ break;
+ }
+
+ case 1://Pure RLE
+ {
+ int left=width, i;
+
+ while (left>0) {
+ stbi_uc count,value[4];
+
+ count=get8u(s);
+ if (at_eof(s)) return epuc("bad file","file too short (pure read count)");
+
+ if (count > left)
+ count = (uint8) left;
+
+ if (!pic_readval(s,packet->channel,value)) return 0;
+
+ for(i=0; i<count; ++i,dest+=4)
+ pic_copyval(packet->channel,dest,value);
+ left -= count;
+ }
+ }
+ break;
+
+ case 2: {//Mixed RLE
+ int left=width;
+ while (left>0) {
+ int count = get8(s), i;
+ if (at_eof(s)) return epuc("bad file","file too short (mixed read count)");
+
+ if (count >= 128) { // Repeated
+ stbi_uc value[4];
+ int i;
+
+ if (count==128)
+ count = get16(s);
+ else
+ count -= 127;
+ if (count > left)
+ return epuc("bad file","scanline overrun");
+
+ if (!pic_readval(s,packet->channel,value))
+ return 0;
+
+ for(i=0;i<count;++i, dest += 4)
+ pic_copyval(packet->channel,dest,value);
+ } else { // Raw
+ ++count;
+ if (count>left) return epuc("bad file","scanline overrun");
+
+ for(i=0;i<count;++i, dest+=4)
+ if (!pic_readval(s,packet->channel,dest))
+ return 0;
+ }
+ left-=count;
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ return result;
+}
+
+static stbi_uc *pic_load(stbi *s,int *px,int *py,int *comp,int req_comp)
+{
+ stbi_uc *result;
+ int i, x,y;
+
+ for (i=0; i<92; ++i)
+ get8(s);
+
+ x = get16(s);
+ y = get16(s);
+ if (at_eof(s)) return epuc("bad file","file too short (pic header)");
+ if ((1 << 28) / x < y) return epuc("too large", "Image too large to decode");
+
+ get32(s); //skip `ratio'
+ get16(s); //skip `fields'
+ get16(s); //skip `pad'
+
+ // intermediate buffer is RGBA
+ result = (stbi_uc *) malloc(x*y*4);
+ memset(result, 0xff, x*y*4);
+
+ if (!pic_load2(s,x,y,comp, result)) {
+ free(result);
+ result=0;
+ }
+ *px = x;
+ *py = y;
+ if (req_comp == 0) req_comp = *comp;
+ result=convert_format(result,4,req_comp,x,y);
+
+ return result;
+}
+
+static int stbi_pic_test(stbi *s)
+{
+ int r = pic_test(s);
+ stbi_rewind(s);
+ return r;
+}
+
+static stbi_uc *stbi_pic_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+ return pic_load(s,x,y,comp,req_comp);
+}
+
+// *************************************************************************************************
+// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
+typedef struct stbi_gif_lzw_struct {
+ int16 prefix;
+ uint8 first;
+ uint8 suffix;
+} stbi_gif_lzw;
+
+typedef struct stbi_gif_struct
+{
+ int w,h;
+ stbi_uc *out; // output buffer (always 4 components)
+ int flags, bgindex, ratio, transparent, eflags;
+ uint8 pal[256][4];
+ uint8 lpal[256][4];
+ stbi_gif_lzw codes[4096];
+ uint8 *color_table;
+ int parse, step;
+ int lflags;
+ int start_x, start_y;
+ int max_x, max_y;
+ int cur_x, cur_y;
+ int line_size;
+} stbi_gif;
+
+static int gif_test(stbi *s)
+{
+ int sz;
+ if (get8(s) != 'G' || get8(s) != 'I' || get8(s) != 'F' || get8(s) != '8') return 0;
+ sz = get8(s);
+ if (sz != '9' && sz != '7') return 0;
+ if (get8(s) != 'a') return 0;
+ return 1;
+}
+
+static int stbi_gif_test(stbi *s)
+{
+ int r = gif_test(s);
+ stbi_rewind(s);
+ return r;
+}
+
+static void stbi_gif_parse_colortable(stbi *s, uint8 pal[256][4], int num_entries, int transp)
+{
+ int i;
+ for (i=0; i < num_entries; ++i) {
+ pal[i][2] = get8u(s);
+ pal[i][1] = get8u(s);
+ pal[i][0] = get8u(s);
+ pal[i][3] = transp ? 0 : 255;
+ }
+}
+
+static int stbi_gif_header(stbi *s, stbi_gif *g, int *comp, int is_info)
+{
+ uint8 version;
+ if (get8(s) != 'G' || get8(s) != 'I' || get8(s) != 'F' || get8(s) != '8')
+ return e("not GIF", "Corrupt GIF");
+
+ version = get8u(s);
+ if (version != '7' && version != '9') return e("not GIF", "Corrupt GIF");
+ if (get8(s) != 'a') return e("not GIF", "Corrupt GIF");
+
+ failure_reason = "";
+ g->w = get16le(s);
+ g->h = get16le(s);
+ g->flags = get8(s);
+ g->bgindex = get8(s);
+ g->ratio = get8(s);
+ g->transparent = -1;
+
+ if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments
+
+ if (is_info) return 1;
+
+ if (g->flags & 0x80)
+ stbi_gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
+
+ return 1;
+}
+
+static int stbi_gif_info_raw(stbi *s, int *x, int *y, int *comp)
+{
+ stbi_gif g;
+ if (!stbi_gif_header(s, &g, comp, 1)) {
+ stbi_rewind( s );
+ return 0;
+ }
+ if (x) *x = g.w;
+ if (y) *y = g.h;
+ return 1;
+}
+
+static void stbi_out_gif_code(stbi_gif *g, uint16 code)
+{
+ uint8 *p, *c;
+
+ // recurse to decode the prefixes, since the linked-list is backwards,
+ // and working backwards through an interleaved image would be nasty
+ if (g->codes[code].prefix >= 0)
+ stbi_out_gif_code(g, g->codes[code].prefix);
+
+ if (g->cur_y >= g->max_y) return;
+
+ p = &g->out[g->cur_x + g->cur_y];
+ c = &g->color_table[g->codes[code].suffix * 4];
+
+ if (c[3] >= 128) {
+ p[0] = c[2];
+ p[1] = c[1];
+ p[2] = c[0];
+ p[3] = c[3];
+ }
+ g->cur_x += 4;
+
+ if (g->cur_x >= g->max_x) {
+ g->cur_x = g->start_x;
+ g->cur_y += g->step;
+
+ while (g->cur_y >= g->max_y && g->parse > 0) {
+ g->step = (1 << g->parse) * g->line_size;
+ g->cur_y = g->start_y + (g->step >> 1);
+ --g->parse;
+ }
+ }
+}
+
+static uint8 *stbi_process_gif_raster(stbi *s, stbi_gif *g)
+{
+ uint8 lzw_cs;
+ int32 len, code;
+ uint32 first;
+ int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
+ stbi_gif_lzw *p;
+
+ lzw_cs = get8u(s);
+ clear = 1 << lzw_cs;
+ first = 1;
+ codesize = lzw_cs + 1;
+ codemask = (1 << codesize) - 1;
+ bits = 0;
+ valid_bits = 0;
+ for (code = 0; code < clear; code++) {
+ g->codes[code].prefix = -1;
+ g->codes[code].first = (uint8) code;
+ g->codes[code].suffix = (uint8) code;
+ }
+
+ // support no starting clear code
+ avail = clear+2;
+ oldcode = -1;
+
+ len = 0;
+ for(;;) {
+ if (valid_bits < codesize) {
+ if (len == 0) {
+ len = get8(s); // start new block
+ if (len == 0)
+ return g->out;
+ }
+ --len;
+ bits |= (int32) get8(s) << valid_bits;
+ valid_bits += 8;
+ } else {
+ int32 code = bits & codemask;
+ bits >>= codesize;
+ valid_bits -= codesize;
+ // @OPTIMIZE: is there some way we can accelerate the non-clear path?
+ if (code == clear) { // clear code
+ codesize = lzw_cs + 1;
+ codemask = (1 << codesize) - 1;
+ avail = clear + 2;
+ oldcode = -1;
+ first = 0;
+ } else if (code == clear + 1) { // end of stream code
+ skip(s, len);
+ while ((len = get8(s)) > 0)
+ skip(s,len);
+ return g->out;
+ } else if (code <= avail) {
+ if (first) return epuc("no clear code", "Corrupt GIF");
+
+ if (oldcode >= 0) {
+ p = &g->codes[avail++];
+ if (avail > 4096) return epuc("too many codes", "Corrupt GIF");
+ p->prefix = (int16) oldcode;
+ p->first = g->codes[oldcode].first;
+ p->suffix = (code == avail) ? p->first : g->codes[code].first;
+ } else if (code == avail)
+ return epuc("illegal code in raster", "Corrupt GIF");
+
+ stbi_out_gif_code(g, (uint16) code);
+
+ if ((avail & codemask) == 0 && avail <= 0x0FFF) {
+ codesize++;
+ codemask = (1 << codesize) - 1;
+ }
+
+ oldcode = code;
+ } else {
+ return epuc("illegal code in raster", "Corrupt GIF");
+ }
+ }
+ }
+}
+
+static void stbi_fill_gif_background(stbi_gif *g)
+{
+ int i;
+ uint8 *c = g->pal[g->bgindex];
+ // @OPTIMIZE: write a dword at a time
+ for (i = 0; i < g->w * g->h * 4; i += 4) {
+ uint8 *p = &g->out[i];
+ p[0] = c[2];
+ p[1] = c[1];
+ p[2] = c[0];
+ p[3] = c[3];
+ }
+}
+
+// this function is designed to support animated gifs, although stb_image doesn't support it
+static uint8 *stbi_gif_load_next(stbi *s, stbi_gif *g, int *comp, int req_comp)
+{
+ int i;
+ uint8 *old_out = 0;
+
+ if (g->out == 0) {
+ if (!stbi_gif_header(s, g, comp,0)) return 0; // failure_reason set by stbi_gif_header
+ g->out = (uint8 *) malloc(4 * g->w * g->h);
+ if (g->out == 0) return epuc("outofmem", "Out of memory");
+ stbi_fill_gif_background(g);
+ } else {
+ // animated-gif-only path
+ if (((g->eflags & 0x1C) >> 2) == 3) {
+ old_out = g->out;
+ g->out = (uint8 *) malloc(4 * g->w * g->h);
+ if (g->out == 0) return epuc("outofmem", "Out of memory");
+ memcpy(g->out, old_out, g->w*g->h*4);
+ }
+ }
+
+ for (;;) {
+ switch (get8(s)) {
+ case 0x2C: /* Image Descriptor */
+ {
+ int32 x, y, w, h;
+ uint8 *o;
+
+ x = get16le(s);
+ y = get16le(s);
+ w = get16le(s);
+ h = get16le(s);
+ if (((x + w) > (g->w)) || ((y + h) > (g->h)))
+ return epuc("bad Image Descriptor", "Corrupt GIF");
+
+ g->line_size = g->w * 4;
+ g->start_x = x * 4;
+ g->start_y = y * g->line_size;
+ g->max_x = g->start_x + w * 4;
+ g->max_y = g->start_y + h * g->line_size;
+ g->cur_x = g->start_x;
+ g->cur_y = g->start_y;
+
+ g->lflags = get8(s);
+
+ if (g->lflags & 0x40) {
+ g->step = 8 * g->line_size; // first interlaced spacing
+ g->parse = 3;
+ } else {
+ g->step = g->line_size;
+ g->parse = 0;
+ }
+
+ if (g->lflags & 0x80) {
+ stbi_gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
+ g->color_table = (uint8 *) g->lpal;
+ } else if (g->flags & 0x80) {
+ for (i=0; i < 256; ++i) // @OPTIMIZE: reset only the previous transparent
+ g->pal[i][3] = 255;
+ if (g->transparent >= 0 && (g->eflags & 0x01))
+ g->pal[g->transparent][3] = 0;
+ g->color_table = (uint8 *) g->pal;
+ } else
+ return epuc("missing color table", "Corrupt GIF");
+
+ o = stbi_process_gif_raster(s, g);
+ if (o == NULL) return NULL;
+
+ if (req_comp && req_comp != 4)
+ o = convert_format(o, 4, req_comp, g->w, g->h);
+ return o;
+ }
+
+ case 0x21: // Comment Extension.
+ {
+ int len;
+ if (get8(s) == 0xF9) { // Graphic Control Extension.
+ len = get8(s);
+ if (len == 4) {
+ g->eflags = get8(s);
+ get16le(s); // delay
+ g->transparent = get8(s);
+ } else {
+ skip(s, len);
+ break;
+ }
+ }
+ while ((len = get8(s)) != 0)
+ skip(s, len);
+ break;
+ }
+
+ case 0x3B: // gif stream termination code
+ return (uint8 *) 1;
+
+ default:
+ return epuc("unknown code", "Corrupt GIF");
+ }
+ }
+}
+
+static stbi_uc *stbi_gif_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+ uint8 *u = 0;
+ stbi_gif g;
+ memset(&g, 0, sizeof(stbi_gif));
+
+ u = stbi_gif_load_next(s, &g, comp, req_comp);
+ if (u == (void *) 1) u = 0; // end of animated gif marker
+ if (u) {
+ *x = g.w;
+ *y = g.h;
+ }
+
+ return u;
+}
+
+static int stbi_gif_info(stbi *s, int *x, int *y, int *comp)
+{
+ return stbi_gif_info_raw(s,x,y,comp);
+}
+
+
+// *************************************************************************************************
+// Radiance RGBE HDR loader
+// originally by Nicolas Schulz
+#ifndef STBI_NO_HDR
+static int hdr_test(stbi *s)
+{
+ const char *signature = "#?RADIANCE\n";
+ int i;
+ for (i=0; signature[i]; ++i)
+ if (get8(s) != signature[i])
+ return 0;
+ return 1;
+}
+
+static int stbi_hdr_test(stbi* s)
+{
+ int r = hdr_test(s);
+ stbi_rewind(s);
+ return r;
+}
+
+#define HDR_BUFLEN 1024
+static char *hdr_gettoken(stbi *z, char *buffer)
+{
+ int len=0;
+ char c = '\0';
+
+ c = (char) get8(z);
+
+ while (!at_eof(z) && c != '\n') {
+ buffer[len++] = c;
+ if (len == HDR_BUFLEN-1) {
+ // flush to end of line
+ while (!at_eof(z) && get8(z) != '\n')
+ ;
+ break;
+ }
+ c = (char) get8(z);
+ }
+
+ buffer[len] = 0;
+ return buffer;
+}
+
+static void hdr_convert(float *output, stbi_uc *input, int req_comp)
+{
+ if ( input[3] != 0 ) {
+ float f1;
+ // Exponent
+ f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
+ if (req_comp <= 2)
+ output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
+ else {
+ output[0] = input[0] * f1;
+ output[1] = input[1] * f1;
+ output[2] = input[2] * f1;
+ }
+ if (req_comp == 2) output[1] = 1;
+ if (req_comp == 4) output[3] = 1;
+ } else {
+ switch (req_comp) {
+ case 4: output[3] = 1; /* fallthrough */
+ case 3: output[0] = output[1] = output[2] = 0;
+ break;
+ case 2: output[1] = 1; /* fallthrough */
+ case 1: output[0] = 0;
+ break;
+ }
+ }
+}
+
+static float *hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+ char buffer[HDR_BUFLEN];
+ char *token;
+ int valid = 0;
+ int width, height;
+ stbi_uc *scanline;
+ float *hdr_data;
+ int len;
+ unsigned char count, value;
+ int i, j, k, c1,c2, z;
+
+
+ // Check identifier
+ if (strcmp(hdr_gettoken(s,buffer), "#?RADIANCE") != 0)
+ return epf("not HDR", "Corrupt HDR image");
+
+ // Parse header
+ for(;;) {
+ token = hdr_gettoken(s,buffer);
+ if (token[0] == 0) break;
+ if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+ }
+
+ if (!valid) return epf("unsupported format", "Unsupported HDR format");
+
+ // Parse width and height
+ // can't use sscanf() if we're not using stdio!
+ token = hdr_gettoken(s,buffer);
+ if (strncmp(token, "-Y ", 3)) return epf("unsupported data layout", "Unsupported HDR format");
+ token += 3;
+ height = strtol(token, &token, 10);
+ while (*token == ' ') ++token;
+ if (strncmp(token, "+X ", 3)) return epf("unsupported data layout", "Unsupported HDR format");
+ token += 3;
+ width = strtol(token, NULL, 10);
+
+ *x = width;
+ *y = height;
+
+ *comp = 3;
+ if (req_comp == 0) req_comp = 3;
+
+ // Read data
+ hdr_data = (float *) malloc(height * width * req_comp * sizeof(float));
+
+ // Load image data
+ // image data is stored as some number of sca
+ if ( width < 8 || width >= 32768) {
+ // Read flat data
+ for (j=0; j < height; ++j) {
+ for (i=0; i < width; ++i) {
+ stbi_uc rgbe[4];
+ main_decode_loop:
+ getn(s, rgbe, 4);
+ hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
+ }
+ }
+ } else {
+ // Read RLE-encoded data
+ scanline = NULL;
+
+ for (j = 0; j < height; ++j) {
+ c1 = get8(s);
+ c2 = get8(s);
+ len = get8(s);
+ if (c1 != 2 || c2 != 2 || (len & 0x80)) {
+ // not run-length encoded, so we have to actually use THIS data as a decoded
+ // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
+ uint8 rgbe[4];
+ rgbe[0] = (uint8) c1;
+ rgbe[1] = (uint8) c2;
+ rgbe[2] = (uint8) len;
+ rgbe[3] = (uint8) get8u(s);
+ hdr_convert(hdr_data, rgbe, req_comp);
+ i = 1;
+ j = 0;
+ free(scanline);
+ goto main_decode_loop; // yes, this makes no sense
+ }
+ len <<= 8;
+ len |= get8(s);
+ if (len != width) { free(hdr_data); free(scanline); return epf("invalid decoded scanline length", "corrupt HDR"); }
+ if (scanline == NULL) scanline = (stbi_uc *) malloc(width * 4);
+
+ for (k = 0; k < 4; ++k) {
+ i = 0;
+ while (i < width) {
+ count = get8u(s);
+ if (count > 128) {
+ // Run
+ value = get8u(s);
+ count -= 128;
+ for (z = 0; z < count; ++z)
+ scanline[i++ * 4 + k] = value;
+ } else {
+ // Dump
+ for (z = 0; z < count; ++z)
+ scanline[i++ * 4 + k] = get8u(s);
+ }
+ }
+ }
+ for (i=0; i < width; ++i)
+ hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
+ }
+ free(scanline);
+ }
+
+ return hdr_data;
+}
+
+static float *stbi_hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+ return hdr_load(s,x,y,comp,req_comp);
+}
+
+static int stbi_hdr_info(stbi *s, int *x, int *y, int *comp)
+{
+ char buffer[HDR_BUFLEN];
+ char *token;
+ int valid = 0;
+
+ if (strcmp(hdr_gettoken(s,buffer), "#?RADIANCE") != 0) {
+ stbi_rewind( s );
+ return 0;
+ }
+
+ for(;;) {
+ token = hdr_gettoken(s,buffer);
+ if (token[0] == 0) break;
+ if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+ }
+
+ if (!valid) {
+ stbi_rewind( s );
+ return 0;
+ }
+ token = hdr_gettoken(s,buffer);
+ if (strncmp(token, "-Y ", 3)) {
+ stbi_rewind( s );
+ return 0;
+ }
+ token += 3;
+ *y = strtol(token, &token, 10);
+ while (*token == ' ') ++token;
+ if (strncmp(token, "+X ", 3)) {
+ stbi_rewind( s );
+ return 0;
+ }
+ token += 3;
+ *x = strtol(token, NULL, 10);
+ *comp = 3;
+ return 1;
+}
+#endif // STBI_NO_HDR
+
+static int stbi_bmp_info(stbi *s, int *x, int *y, int *comp)
+{
+ int hsz;
+ if (get8(s) != 'B' || get8(s) != 'M') {
+ stbi_rewind( s );
+ return 0;
+ }
+ skip(s,12);
+ hsz = get32le(s);
+ if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108) {
+ stbi_rewind( s );
+ return 0;
+ }
+ if (hsz == 12) {
+ *x = get16le(s);
+ *y = get16le(s);
+ } else {
+ *x = get32le(s);
+ *y = get32le(s);
+ }
+ if (get16le(s) != 1) {
+ stbi_rewind( s );
+ return 0;
+ }
+ *comp = get16le(s) / 8;
+ return 1;
+}
+
+static int stbi_psd_info(stbi *s, int *x, int *y, int *comp)
+{
+ int channelCount;
+ if (get32(s) != 0x38425053) {
+ stbi_rewind( s );
+ return 0;
+ }
+ if (get16(s) != 1) {
+ stbi_rewind( s );
+ return 0;
+ }
+ skip(s, 6);
+ channelCount = get16(s);
+ if (channelCount < 0 || channelCount > 16) {
+ stbi_rewind( s );
+ return 0;
+ }
+ *y = get32(s);
+ *x = get32(s);
+ if (get16(s) != 8) {
+ stbi_rewind( s );
+ return 0;
+ }
+ if (get16(s) != 3) {
+ stbi_rewind( s );
+ return 0;
+ }
+ *comp = 4;
+ return 1;
+}
+
+static int stbi_pic_info(stbi *s, int *x, int *y, int *comp)
+{
+ int act_comp=0,num_packets=0,chained;
+ pic_packet_t packets[10];
+
+ skip(s, 92);
+
+ *x = get16(s);
+ *y = get16(s);
+ if (at_eof(s)) return 0;
+ if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
+ stbi_rewind( s );
+ return 0;
+ }
+
+ skip(s, 8);
+
+ do {
+ pic_packet_t *packet;
+
+ if (num_packets==sizeof(packets)/sizeof(packets[0]))
+ return 0;
+
+ packet = &packets[num_packets++];
+ chained = get8(s);
+ packet->size = get8u(s);
+ packet->type = get8u(s);
+ packet->channel = get8u(s);
+ act_comp |= packet->channel;
+
+ if (at_eof(s)) {
+ stbi_rewind( s );
+ return 0;
+ }
+ if (packet->size != 8) {
+ stbi_rewind( s );
+ return 0;
+ }
+ } while (chained);
+
+ *comp = (act_comp & 0x10 ? 4 : 3);
+
+ return 1;
+}
+
+static int stbi_info_main(stbi *s, int *x, int *y, int *comp)
+{
+ if (stbi_jpeg_info(s, x, y, comp))
+ return 1;
+ if (stbi_png_info(s, x, y, comp))
+ return 1;
+ if (stbi_gif_info(s, x, y, comp))
+ return 1;
+ if (stbi_bmp_info(s, x, y, comp))
+ return 1;
+ if (stbi_psd_info(s, x, y, comp))
+ return 1;
+ if (stbi_pic_info(s, x, y, comp))
+ return 1;
+ #ifndef STBI_NO_HDR
+ if (stbi_hdr_info(s, x, y, comp))
+ return 1;
+ #endif
+ // test tga last because it's a crappy test!
+ if (stbi_tga_info(s, x, y, comp))
+ return 1;
+ return e("unknown image type", "Image not of any known type, or corrupt");
+}
+
+#ifndef STBI_NO_STDIO
+int stbi_info(char const *filename, int *x, int *y, int *comp)
+{
+ FILE *f = fopen(filename, "rb");
+ int result;
+ if (!f) return e("can't fopen", "Unable to open file");
+ result = stbi_info_from_file(f, x, y, comp);
+ fclose(f);
+ return result;
+}
+
+int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
+{
+ int r;
+ stbi s;
+ long pos = ftell(f);
+ start_file(&s, f);
+ r = stbi_info_main(&s,x,y,comp);
+ fseek(f,pos,SEEK_SET);
+ return r;
+}
+#endif // !STBI_NO_STDIO
+
+int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
+{
+ stbi s;
+ start_mem(&s,buffer,len);
+ return stbi_info_main(&s,x,y,comp);
+}
+
+int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
+{
+ stbi s;
+ start_callbacks(&s, (stbi_io_callbacks *) c, user);
+ return stbi_info_main(&s,x,y,comp);
+}
+
+#endif // STBI_HEADER_FILE_ONLY
+
+/*
+ revision history:
+ 1.33 (2011-07-14)
+ make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements
+ 1.32 (2011-07-13)
+ support for "info" function for all supported filetypes (SpartanJ)
+ 1.31 (2011-06-20)
+ a few more leak fixes, bug in PNG handling (SpartanJ)
+ 1.30 (2011-06-11)
+ added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)
+ removed deprecated format-specific test/load functions
+ removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway
+ error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)
+ fix inefficiency in decoding 32-bit BMP (David Woo)
+ 1.29 (2010-08-16)
+ various warning fixes from Aurelien Pocheville
+ 1.28 (2010-08-01)
+ fix bug in GIF palette transparency (SpartanJ)
+ 1.27 (2010-08-01)
+ cast-to-uint8 to fix warnings
+ 1.26 (2010-07-24)
+ fix bug in file buffering for PNG reported by SpartanJ
+ 1.25 (2010-07-17)
+ refix trans_data warning (Won Chun)
+ 1.24 (2010-07-12)
+ perf improvements reading from files on platforms with lock-heavy fgetc()
+ minor perf improvements for jpeg
+ deprecated type-specific functions so we'll get feedback if they're needed
+ attempt to fix trans_data warning (Won Chun)
+ 1.23 fixed bug in iPhone support
+ 1.22 (2010-07-10)
+ removed image *writing* support
+ stbi_info support from Jetro Lauha
+ GIF support from Jean-Marc Lienher
+ iPhone PNG-extensions from James Brown
+ warning-fixes from Nicolas Schulz and Janez Zemva (i.e. Janez (U+017D)emva)
+ 1.21 fix use of 'uint8' in header (reported by jon blow)
+ 1.20 added support for Softimage PIC, by Tom Seddon
+ 1.19 bug in interlaced PNG corruption check (found by ryg)
+ 1.18 2008-08-02
+ fix a threading bug (local mutable static)
+ 1.17 support interlaced PNG
+ 1.16 major bugfix - convert_format converted one too many pixels
+ 1.15 initialize some fields for thread safety
+ 1.14 fix threadsafe conversion bug
+ header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
+ 1.13 threadsafe
+ 1.12 const qualifiers in the API
+ 1.11 Support installable IDCT, colorspace conversion routines
+ 1.10 Fixes for 64-bit (don't use "unsigned long")
+ optimized upsampling by Fabian "ryg" Giesen
+ 1.09 Fix format-conversion for PSD code (bad global variables!)
+ 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz
+ 1.07 attempt to fix C++ warning/errors again
+ 1.06 attempt to fix C++ warning/errors again
+ 1.05 fix TGA loading to return correct *comp and use good luminance calc
+ 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free
+ 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR
+ 1.02 support for (subset of) HDR files, float interface for preferred access to them
+ 1.01 fix bug: possible bug in handling right-side up bmps... not sure
+ fix bug: the stbi_bmp_load() and stbi_tga_load() functions didn't work at all
+ 1.00 interface to zlib that skips zlib header
+ 0.99 correct handling of alpha in palette
+ 0.98 TGA loader by lonesock; dynamically add loaders (untested)
+ 0.97 jpeg errors on too large a file; also catch another malloc failure
+ 0.96 fix detection of invalid v value - particleman@mollyrocket forum
+ 0.95 during header scan, seek to markers in case of padding
+ 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same
+ 0.93 handle jpegtran output; verbose errors
+ 0.92 read 4,8,16,24,32-bit BMP files of several formats
+ 0.91 output 24-bit Windows 3.0 BMP files
+ 0.90 fix a few more warnings; bump version number to approach 1.0
+ 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd
+ 0.60 fix compiling as c++
+ 0.59 fix warnings: merge Dave Moore's -Wall fixes
+ 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian
+ 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available
+ 0.56 fix bug: zlib uncompressed mode len vs. nlen
+ 0.55 fix bug: restart_interval not initialized to 0
+ 0.54 allow NULL for 'int *comp'
+ 0.53 fix bug in png 3->4; speedup png decoding
+ 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments
+ 0.51 obey req_comp requests, 1-component jpegs return as 1-component,
+ on 'test' only check type, not whether we support this variant
+ 0.50 first released version
+*/
diff --git a/libs/dgl/src/nanovg/stb_truetype.h b/libs/dgl/src/nanovg/stb_truetype.h new file mode 100644 index 0000000..9290789 --- /dev/null +++ b/libs/dgl/src/nanovg/stb_truetype.h @@ -0,0 +1,2064 @@ +// stb_truetype.h - v0.6c - public domain
+// authored from 2009-2012 by Sean Barrett / RAD Game Tools
+//
+// This library processes TrueType files:
+// parse files
+// extract glyph metrics
+// extract glyph shapes
+// render glyphs to one-channel bitmaps with antialiasing (box filter)
+//
+// Todo:
+// non-MS cmaps
+// crashproof on bad data
+// hinting? (no longer patented)
+// cleartype-style AA?
+// optimize: use simple memory allocator for intermediates
+// optimize: build edge-list directly from curves
+// optimize: rasterize directly from curves?
+//
+// ADDITIONAL CONTRIBUTORS
+//
+// Mikko Mononen: compound shape support, more cmap formats
+// Tor Andersson: kerning, subpixel rendering
+//
+// Bug/warning reports:
+// "Zer" on mollyrocket (with fix)
+// Cass Everitt
+// stoiko (Haemimont Games)
+// Brian Hook
+// Walter van Niftrik
+//
+// VERSION HISTORY
+//
+// 0.6c (2012-07-24) improve documentation
+// 0.6b (2012-07-20) fix a few more warnings
+// 0.6 (2012-07-17) fix warnings; added stbtt_ScaleForMappingEmToPixels,
+// stbtt_GetFontBoundingBox, stbtt_IsGlyphEmpty
+// 0.5 (2011-12-09) bugfixes:
+// subpixel glyph renderer computed wrong bounding box
+// first vertex of shape can be off-curve (FreeSans)
+// 0.4b (2011-12-03) fixed an error in the font baking example
+// 0.4 (2011-12-01) kerning, subpixel rendering (tor)
+// bugfixes for:
+// codepoint-to-glyph conversion using table fmt=12
+// codepoint-to-glyph conversion using table fmt=4
+// stbtt_GetBakedQuad with non-square texture (Zer)
+// updated Hello World! sample to use kerning and subpixel
+// fixed some warnings
+// 0.3 (2009-06-24) cmap fmt=12, compound shapes (MM)
+// userdata, malloc-from-userdata, non-zero fill (STB)
+// 0.2 (2009-03-11) Fix unsigned/signed char warnings
+// 0.1 (2009-03-09) First public release
+//
+// LICENSE
+//
+// This software is in the public domain. Where that dedication is not
+// recognized, you are granted a perpetual, irrevokable license to copy
+// and modify this file as you see fit.
+//
+// USAGE
+//
+// Include this file in whatever places neeed to refer to it. In ONE C/C++
+// file, write:
+// #define STB_TRUETYPE_IMPLEMENTATION
+// before the #include of this file. This expands out the actual
+// implementation into that C/C++ file.
+//
+// Simple 3D API (don't ship this, but it's fine for tools and quick start,
+// and you can cut and paste from it to move to more advanced)
+// stbtt_BakeFontBitmap() -- bake a font to a bitmap for use as texture
+// stbtt_GetBakedQuad() -- compute quad to draw for a given char
+//
+// "Load" a font file from a memory buffer (you have to keep the buffer loaded)
+// stbtt_InitFont()
+// stbtt_GetFontOffsetForIndex() -- use for TTC font collections
+//
+// Render a unicode codepoint to a bitmap
+// stbtt_GetCodepointBitmap() -- allocates and returns a bitmap
+// stbtt_MakeCodepointBitmap() -- renders into bitmap you provide
+// stbtt_GetCodepointBitmapBox() -- how big the bitmap must be
+//
+// Character advance/positioning
+// stbtt_GetCodepointHMetrics()
+// stbtt_GetFontVMetrics()
+// stbtt_GetCodepointKernAdvance()
+//
+// ADDITIONAL DOCUMENTATION
+//
+// Immediately after this block comment are a series of sample programs.
+//
+// After the sample programs is the "header file" section. This section
+// includes documentation for each API function.
+//
+// Some important concepts to understand to use this library:
+//
+// Codepoint
+// Characters are defined by unicode codepoints, e.g. 65 is
+// uppercase A, 231 is lowercase c with a cedilla, 0x7e30 is
+// the hiragana for "ma".
+//
+// Glyph
+// A visual character shape (every codepoint is rendered as
+// some glyph)
+//
+// Glyph index
+// A font-specific integer ID representing a glyph
+//
+// Baseline
+// Glyph shapes are defined relative to a baseline, which is the
+// bottom of uppercase characters. Characters extend both above
+// and below the baseline.
+//
+// Current Point
+// As you draw text to the screen, you keep track of a "current point"
+// which is the origin of each character. The current point's vertical
+// position is the baseline. Even "baked fonts" use this model.
+//
+// Vertical Font Metrics
+// The vertical qualities of the font, used to vertically position
+// and space the characters. See docs for stbtt_GetFontVMetrics.
+//
+// Font Size in Pixels or Points
+// The preferred interface for specifying font sizes in stb_truetype
+// is to specify how tall the font's vertical extent should be in pixels.
+// If that sounds good enough, skip the next paragraph.
+//
+// Most font APIs instead use "points", which are a common typographic
+// measurement for describing font size, defined as 72 points per inch.
+// stb_truetype provides a point API for compatibility. However, true
+// "per inch" conventions don't make much sense on computer displays
+// since they different monitors have different number of pixels per
+// inch. For example, Windows traditionally uses a convention that
+// there are 96 pixels per inch, thus making 'inch' measurements have
+// nothing to do with inches, and thus effectively defining a point to
+// be 1.333 pixels. Additionally, the TrueType font data provides
+// an explicit scale factor to scale a given font's glyphs to points,
+// but the author has observed that this scale factor is often wrong
+// for non-commercial fonts, thus making fonts scaled in points
+// according to the TrueType spec incoherently sized in practice.
+//
+// ADVANCED USAGE
+//
+// Quality:
+//
+// - Use the functions with Subpixel at the end to allow your characters
+// to have subpixel positioning. Since the font is anti-aliased, not
+// hinted, this is very import for quality. (This is not possible with
+// baked fonts.)
+//
+// - Kerning is now supported, and if you're supporting subpixel rendering
+// then kerning is worth using to give your text a polished look.
+//
+// Performance:
+//
+// - Convert Unicode codepoints to glyph indexes and operate on the glyphs;
+// if you don't do this, stb_truetype is forced to do the conversion on
+// every call.
+//
+// - There are a lot of memory allocations. We should modify it to take
+// a temp buffer and allocate from the temp buffer (without freeing),
+// should help performance a lot.
+//
+// NOTES
+//
+// The system uses the raw data found in the .ttf file without changing it
+// and without building auxiliary data structures. This is a bit inefficient
+// on little-endian systems (the data is big-endian), but assuming you're
+// caching the bitmaps or glyph shapes this shouldn't be a big deal.
+//
+// It appears to be very hard to programmatically determine what font a
+// given file is in a general way. I provide an API for this, but I don't
+// recommend it.
+//
+//
+// SOURCE STATISTICS (based on v0.6c, 2050 LOC)
+//
+// Documentation & header file 520 LOC \___ 660 LOC documentation
+// Sample code 140 LOC /
+// Truetype parsing 620 LOC ---- 620 LOC TrueType
+// Software rasterization 240 LOC \ .
+// Curve tesselation 120 LOC \__ 550 LOC Bitmap creation
+// Bitmap management 100 LOC /
+// Baked bitmap interface 70 LOC /
+// Font name matching & access 150 LOC ---- 150
+// C runtime library abstraction 60 LOC ---- 60
+
+
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+////
+//// SAMPLE PROGRAMS
+////
+//
+// Incomplete text-in-3d-api example, which draws quads properly aligned to be lossless
+//
+#if 0
+#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation
+#include "stb_truetype.h"
+
+char ttf_buffer[1<<20];
+unsigned char temp_bitmap[512*512];
+
+stbtt_bakedchar cdata[96]; // ASCII 32..126 is 95 glyphs
+GLstbtt_uint ftex;
+
+void my_stbtt_initfont(void)
+{
+ fread(ttf_buffer, 1, 1<<20, fopen("c:/windows/fonts/times.ttf", "rb"));
+ stbtt_BakeFontBitmap(data,0, 32.0, temp_bitmap,512,512, 32,96, cdata); // no guarantee this fits!
+ // can free ttf_buffer at this point
+ glGenTextures(1, &ftex);
+ glBindTexture(GL_TEXTURE_2D, ftex);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 512,512, 0, GL_ALPHA, GL_UNSIGNED_BYTE, temp_bitmap);
+ // can free temp_bitmap at this point
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+}
+
+void my_stbtt_print(float x, float y, char *text)
+{
+ // assume orthographic projection with units = screen pixels, origin at top left
+ glBindTexture(GL_TEXTURE_2D, ftex);
+ glBegin(GL_QUADS);
+ while (*text) {
+ if (*text >= 32 && *text < 128) {
+ stbtt_aligned_quad q;
+ stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);//1=opengl,0=old d3d
+ glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y0);
+ glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y0);
+ glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y1);
+ glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y1);
+ }
+ ++text;
+ }
+ glEnd();
+}
+#endif
+//
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Complete program (this compiles): get a single bitmap, print as ASCII art
+//
+#if 0
+#include <stdio.h>
+#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation
+#include "stb_truetype.h"
+
+char ttf_buffer[1<<25];
+
+int main(int argc, char **argv)
+{
+ stbtt_fontinfo font;
+ unsigned char *bitmap;
+ int w,h,i,j,c = (argc > 1 ? atoi(argv[1]) : 'a'), s = (argc > 2 ? atoi(argv[2]) : 20);
+
+ fread(ttf_buffer, 1, 1<<25, fopen(argc > 3 ? argv[3] : "c:/windows/fonts/arialbd.ttf", "rb"));
+
+ stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer,0));
+ bitmap = stbtt_GetCodepointBitmap(&font, 0,stbtt_ScaleForPixelHeight(&font, s), c, &w, &h, 0,0);
+
+ for (j=0; j < h; ++j) {
+ for (i=0; i < w; ++i)
+ putchar(" .:ioVM@"[bitmap[j*w+i]>>5]);
+ putchar('\n');
+ }
+ return 0;
+}
+#endif
+//
+// Output:
+//
+// .ii.
+// @@@@@@.
+// V@Mio@@o
+// :i. V@V
+// :oM@@M
+// :@@@MM@M
+// @@o o@M
+// :@@. M@M
+// @@@o@@@@
+// :M@@V:@@.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Complete program: print "Hello World!" banner, with bugs
+//
+#if 0
+char buffer[24<<20];
+unsigned char screen[20][79];
+
+int main(int arg, char **argv)
+{
+ stbtt_fontinfo font;
+ int i,j,ascent,baseline,ch=0;
+ float scale, xpos=0;
+ char *text = "Heljo World!";
+
+ fread(buffer, 1, 1000000, fopen("c:/windows/fonts/arialbd.ttf", "rb"));
+ stbtt_InitFont(&font, buffer, 0);
+
+ scale = stbtt_ScaleForPixelHeight(&font, 15);
+ stbtt_GetFontVMetrics(&font, &ascent,0,0);
+ baseline = (int) (ascent*scale);
+
+ while (text[ch]) {
+ int advance,lsb,x0,y0,x1,y1;
+ float x_shift = xpos - (float) floor(xpos);
+ stbtt_GetCodepointHMetrics(&font, text[ch], &advance, &lsb);
+ stbtt_GetCodepointBitmapBoxSubpixel(&font, text[ch], scale,scale,x_shift,0, &x0,&y0,&x1,&y1);
+ stbtt_MakeCodepointBitmapSubpixel(&font, &screen[baseline + y0][(int) xpos + x0], x1-x0,y1-y0, 79, scale,scale,x_shift,0, text[ch]);
+ // note that this stomps the old data, so where character boxes overlap (e.g. 'lj') it's wrong
+ // because this API is really for baking character bitmaps into textures. if you want to render
+ // a sequence of characters, you really need to render each bitmap to a temp buffer, then
+ // "alpha blend" that into the working buffer
+ xpos += (advance * scale);
+ if (text[ch+1])
+ xpos += scale*stbtt_GetCodepointKernAdvance(&font, text[ch],text[ch+1]);
+ ++ch;
+ }
+
+ for (j=0; j < 20; ++j) {
+ for (i=0; i < 78; ++i)
+ putchar(" .:ioVM@"[screen[j][i]>>5]);
+ putchar('\n');
+ }
+
+ return 0;
+}
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+////
+//// INTEGRATION WITH YOUR CODEBASE
+////
+//// The following sections allow you to supply alternate definitions
+//// of C library functions used by stb_truetype.
+
+#ifdef STB_TRUETYPE_IMPLEMENTATION
+ // #define your own (u)stbtt_int8/16/32 before including to override this
+ #ifndef stbtt_uint8
+ typedef unsigned char stbtt_uint8;
+ typedef signed char stbtt_int8;
+ typedef unsigned short stbtt_uint16;
+ typedef signed short stbtt_int16;
+ typedef unsigned int stbtt_uint32;
+ typedef signed int stbtt_int32;
+ #endif
+
+ typedef char stbtt__check_size32[sizeof(stbtt_int32)==4 ? 1 : -1];
+ typedef char stbtt__check_size16[sizeof(stbtt_int16)==2 ? 1 : -1];
+
+ // #define your own STBTT_sort() to override this to avoid qsort
+ #ifndef STBTT_sort
+ #include <stdlib.h>
+ #define STBTT_sort(data,num_items,item_size,compare_func) qsort(data,num_items,item_size,compare_func)
+ #endif
+
+ // #define your own STBTT_ifloor/STBTT_iceil() to avoid math.h
+ #ifndef STBTT_ifloor
+ #include <math.h>
+ #define STBTT_ifloor(x) ((int) floor(x))
+ #define STBTT_iceil(x) ((int) ceil(x))
+ #endif
+
+ // #define your own functions "STBTT_malloc" / "STBTT_free" to avoid malloc.h
+ #ifndef STBTT_malloc
+ #include <malloc.h>
+ #define STBTT_malloc(x,u) malloc(x)
+ #define STBTT_free(x,u) free(x)
+ #endif
+
+ #ifndef STBTT_assert
+ #include <assert.h>
+ #define STBTT_assert(x) assert(x)
+ #endif
+
+ #ifndef STBTT_strlen
+ #include <string.h>
+ #define STBTT_strlen(x) strlen(x)
+ #endif
+
+ #ifndef STBTT_memcpy
+ #include <memory.h>
+ #define STBTT_memcpy memcpy
+ #define STBTT_memset memset
+ #endif
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+////
+//// INTERFACE
+////
+////
+
+#ifndef __STB_INCLUDE_STB_TRUETYPE_H__
+#define __STB_INCLUDE_STB_TRUETYPE_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// TEXTURE BAKING API
+//
+// If you use this API, you only have to call two functions ever.
+//
+
+typedef struct
+{
+ unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap
+ float xoff,yoff,xadvance;
+} stbtt_bakedchar;
+
+extern int stbtt_BakeFontBitmap(const unsigned char *data, int offset, // font location (use offset=0 for plain .ttf)
+ float pixel_height, // height of font in pixels
+ unsigned char *pixels, int pw, int ph, // bitmap to be filled in
+ int first_char, int num_chars, // characters to bake
+ stbtt_bakedchar *chardata); // you allocate this, it's num_chars long
+// if return is positive, the first unused row of the bitmap
+// if return is negative, returns the negative of the number of characters that fit
+// if return is 0, no characters fit and no rows were used
+// This uses a very crappy packing.
+
+typedef struct
+{
+ float x0,y0,s0,t0; // top-left
+ float x1,y1,s1,t1; // bottom-right
+} stbtt_aligned_quad;
+
+extern void stbtt_GetBakedQuad(stbtt_bakedchar *chardata, int pw, int ph, // same data as above
+ int char_index, // character to display
+ float *xpos, float *ypos, // pointers to current position in screen pixel space
+ stbtt_aligned_quad *q, // output: quad to draw
+ int opengl_fillrule); // true if opengl fill rule; false if DX9 or earlier
+// Call GetBakedQuad with char_index = 'character - first_char', and it
+// creates the quad you need to draw and advances the current position.
+//
+// The coordinate system used assumes y increases downwards.
+//
+// Characters will extend both above and below the current position;
+// see discussion of "BASELINE" above.
+//
+// It's inefficient; you might want to c&p it and optimize it.
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// FONT LOADING
+//
+//
+
+extern int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index);
+// Each .ttf/.ttc file may have more than one font. Each font has a sequential
+// index number starting from 0. Call this function to get the font offset for
+// a given index; it returns -1 if the index is out of range. A regular .ttf
+// file will only define one font and it always be at offset 0, so it will
+// return '0' for index 0, and -1 for all other indices. You can just skip
+// this step if you know it's that kind of font.
+
+
+// The following structure is defined publically so you can declare one on
+// the stack or as a global or etc, but you should treat it as opaque.
+typedef struct stbtt_fontinfo
+{
+ void * userdata;
+ unsigned char * data; // pointer to .ttf file
+ int fontstart; // offset of start of font
+
+ int numGlyphs; // number of glyphs, needed for range checking
+
+ int loca,head,glyf,hhea,hmtx,kern; // table locations as offset from start of .ttf
+ int index_map; // a cmap mapping for our chosen character encoding
+ int indexToLocFormat; // format needed to map from glyph index to glyph
+} stbtt_fontinfo;
+
+extern int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset);
+// Given an offset into the file that defines a font, this function builds
+// the necessary cached info for the rest of the system. You must allocate
+// the stbtt_fontinfo yourself, and stbtt_InitFont will fill it out. You don't
+// need to do anything special to free it, because the contents are pure
+// value data with no additional data structures. Returns 0 on failure.
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// CHARACTER TO GLYPH-INDEX CONVERSIOn
+
+int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint);
+// If you're going to perform multiple operations on the same character
+// and you want a speed-up, call this function with the character you're
+// going to process, then use glyph-based functions instead of the
+// codepoint-based functions.
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// CHARACTER PROPERTIES
+//
+
+extern float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float pixels);
+// computes a scale factor to produce a font whose "height" is 'pixels' tall.
+// Height is measured as the distance from the highest ascender to the lowest
+// descender; in other words, it's equivalent to calling stbtt_GetFontVMetrics
+// and computing:
+// scale = pixels / (ascent - descent)
+// so if you prefer to measure height by the ascent only, use a similar calculation.
+
+extern float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels);
+// computes a scale factor to produce a font whose EM size is mapped to
+// 'pixels' tall. This is probably what traditional APIs compute, but
+// I'm not positive.
+
+extern void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap);
+// ascent is the coordinate above the baseline the font extends; descent
+// is the coordinate below the baseline the font extends (i.e. it is typically negative)
+// lineGap is the spacing between one row's descent and the next row's ascent...
+// so you should advance the vertical position by "*ascent - *descent + *lineGap"
+// these are expressed in unscaled coordinates, so you must multiply by
+// the scale factor for a given size
+
+extern void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1);
+// the bounding box around all possible characters
+
+extern void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing);
+// leftSideBearing is the offset from the current horizontal position to the left edge of the character
+// advanceWidth is the offset from the current horizontal position to the next horizontal position
+// these are expressed in unscaled coordinates
+
+extern int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2);
+// an additional amount to add to the 'advance' value between ch1 and ch2
+// @TODO; for now always returns 0!
+
+extern int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1);
+// Gets the bounding box of the visible part of the glyph, in unscaled coordinates
+
+extern void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing);
+extern int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2);
+extern int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1);
+// as above, but takes one or more glyph indices for greater efficiency
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// GLYPH SHAPES (you probably don't need these, but they have to go before
+// the bitmaps for C declaration-order reasons)
+//
+
+#ifndef STBTT_vmove // you can predefine these to use different values (but why?)
+ enum {
+ STBTT_vmove=1,
+ STBTT_vline,
+ STBTT_vcurve
+ };
+#endif
+
+#ifndef stbtt_vertex // you can predefine this to use different values
+ // (we share this with other code at RAD)
+ #define stbtt_vertex_type short // can't use stbtt_int16 because that's not visible in the header file
+ typedef struct
+ {
+ stbtt_vertex_type x,y,cx,cy;
+ unsigned char type,padding;
+ } stbtt_vertex;
+#endif
+
+extern int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index);
+// returns non-zero if nothing is drawn for this glyph
+
+extern int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices);
+extern int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices);
+// returns # of vertices and fills *vertices with the pointer to them
+// these are expressed in "unscaled" coordinates
+
+extern void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices);
+// frees the data allocated above
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// BITMAP RENDERING
+//
+
+extern void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata);
+// frees the bitmap allocated below
+
+extern unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff);
+// allocates a large-enough single-channel 8bpp bitmap and renders the
+// specified character/glyph at the specified scale into it, with
+// antialiasing. 0 is no coverage (transparent), 255 is fully covered (opaque).
+// *width & *height are filled out with the width & height of the bitmap,
+// which is stored left-to-right, top-to-bottom.
+//
+// xoff/yoff are the offset it pixel space from the glyph origin to the top-left of the bitmap
+
+extern unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff);
+// the same as stbtt_GetCodepoitnBitmap, but you can specify a subpixel
+// shift for the character
+
+extern void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint);
+// the same as stbtt_GetCodepointBitmap, but you pass in storage for the bitmap
+// in the form of 'output', with row spacing of 'out_stride' bytes. the bitmap
+// is clipped to out_w/out_h bytes. Call stbtt_GetCodepointBitmapBox to get the
+// width and height and positioning info for it first.
+
+extern void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint);
+// same as stbtt_MakeCodepointBitmap, but you can specify a subpixel
+// shift for the character
+
+extern void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1);
+// get the bbox of the bitmap centered around the glyph origin; so the
+// bitmap width is ix1-ix0, height is iy1-iy0, and location to place
+// the bitmap top left is (leftSideBearing*scale,iy0).
+// (Note that the bitmap uses y-increases-down, but the shape uses
+// y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.)
+
+extern void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1);
+// same as stbtt_GetCodepointBitmapBox, but you can specify a subpixel
+// shift for the character
+
+// the following functions are equivalent to the above functions, but operate
+// on glyph indices instead of Unicode codepoints (for efficiency)
+extern unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff);
+extern unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff);
+extern void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph);
+extern void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph);
+extern void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1);
+extern void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1);
+
+
+// @TODO: don't expose this structure
+typedef struct
+{
+ int w,h,stride;
+ unsigned char *pixels;
+} stbtt__bitmap;
+
+extern void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata);
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Finding the right font...
+//
+// You should really just solve this offline, keep your own tables
+// of what font is what, and don't try to get it out of the .ttf file.
+// That's because getting it out of the .ttf file is really hard, because
+// the names in the file can appear in many possible encodings, in many
+// possible languages, and e.g. if you need a case-insensitive comparison,
+// the details of that depend on the encoding & language in a complex way
+// (actually underspecified in truetype, but also gigantic).
+//
+// But you can use the provided functions in two possible ways:
+// stbtt_FindMatchingFont() will use *case-sensitive* comparisons on
+// unicode-encoded names to try to find the font you want;
+// you can run this before calling stbtt_InitFont()
+//
+// stbtt_GetFontNameString() lets you get any of the various strings
+// from the file yourself and do your own comparisons on them.
+// You have to have called stbtt_InitFont() first.
+
+
+extern int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags);
+// returns the offset (not index) of the font that matches, or -1 if none
+// if you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold".
+// if you use any other flag, use a font name like "Arial"; this checks
+// the 'macStyle' header field; i don't know if fonts set this consistently
+#define STBTT_MACSTYLE_DONTCARE 0
+#define STBTT_MACSTYLE_BOLD 1
+#define STBTT_MACSTYLE_ITALIC 2
+#define STBTT_MACSTYLE_UNDERSCORE 4
+#define STBTT_MACSTYLE_NONE 8 // <= not same as 0, this makes us check the bitfield is 0
+
+extern int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2);
+// returns 1/0 whether the first string interpreted as utf8 is identical to
+// the second string interpreted as big-endian utf16... useful for strings from next func
+
+extern const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID);
+// returns the string (which may be big-endian double byte, e.g. for unicode)
+// and puts the length in bytes in *length.
+//
+// some of the values for the IDs are below; for more see the truetype spec:
+// http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html
+// http://www.microsoft.com/typography/otspec/name.htm
+
+enum { // platformID
+ STBTT_PLATFORM_ID_UNICODE =0,
+ STBTT_PLATFORM_ID_MAC =1,
+ STBTT_PLATFORM_ID_ISO =2,
+ STBTT_PLATFORM_ID_MICROSOFT =3
+};
+
+enum { // encodingID for STBTT_PLATFORM_ID_UNICODE
+ STBTT_UNICODE_EID_UNICODE_1_0 =0,
+ STBTT_UNICODE_EID_UNICODE_1_1 =1,
+ STBTT_UNICODE_EID_ISO_10646 =2,
+ STBTT_UNICODE_EID_UNICODE_2_0_BMP=3,
+ STBTT_UNICODE_EID_UNICODE_2_0_FULL=4
+};
+
+enum { // encodingID for STBTT_PLATFORM_ID_MICROSOFT
+ STBTT_MS_EID_SYMBOL =0,
+ STBTT_MS_EID_UNICODE_BMP =1,
+ STBTT_MS_EID_SHIFTJIS =2,
+ STBTT_MS_EID_UNICODE_FULL =10
+};
+
+enum { // encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes
+ STBTT_MAC_EID_ROMAN =0, STBTT_MAC_EID_ARABIC =4,
+ STBTT_MAC_EID_JAPANESE =1, STBTT_MAC_EID_HEBREW =5,
+ STBTT_MAC_EID_CHINESE_TRAD =2, STBTT_MAC_EID_GREEK =6,
+ STBTT_MAC_EID_KOREAN =3, STBTT_MAC_EID_RUSSIAN =7
+};
+
+enum { // languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID...
+ // problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs
+ STBTT_MS_LANG_ENGLISH =0x0409, STBTT_MS_LANG_ITALIAN =0x0410,
+ STBTT_MS_LANG_CHINESE =0x0804, STBTT_MS_LANG_JAPANESE =0x0411,
+ STBTT_MS_LANG_DUTCH =0x0413, STBTT_MS_LANG_KOREAN =0x0412,
+ STBTT_MS_LANG_FRENCH =0x040c, STBTT_MS_LANG_RUSSIAN =0x0419,
+ STBTT_MS_LANG_GERMAN =0x0407, STBTT_MS_LANG_SPANISH =0x0409,
+ STBTT_MS_LANG_HEBREW =0x040d, STBTT_MS_LANG_SWEDISH =0x041D
+};
+
+enum { // languageID for STBTT_PLATFORM_ID_MAC
+ STBTT_MAC_LANG_ENGLISH =0 , STBTT_MAC_LANG_JAPANESE =11,
+ STBTT_MAC_LANG_ARABIC =12, STBTT_MAC_LANG_KOREAN =23,
+ STBTT_MAC_LANG_DUTCH =4 , STBTT_MAC_LANG_RUSSIAN =32,
+ STBTT_MAC_LANG_FRENCH =1 , STBTT_MAC_LANG_SPANISH =6 ,
+ STBTT_MAC_LANG_GERMAN =2 , STBTT_MAC_LANG_SWEDISH =5 ,
+ STBTT_MAC_LANG_HEBREW =10, STBTT_MAC_LANG_CHINESE_SIMPLIFIED =33,
+ STBTT_MAC_LANG_ITALIAN =3 , STBTT_MAC_LANG_CHINESE_TRAD =19
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __STB_INCLUDE_STB_TRUETYPE_H__
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+////
+//// IMPLEMENTATION
+////
+////
+
+#ifdef STB_TRUETYPE_IMPLEMENTATION
+
+//////////////////////////////////////////////////////////////////////////
+//
+// accessors to parse data from file
+//
+
+// on platforms that don't allow misaligned reads, if we want to allow
+// truetype fonts that aren't padded to alignment, define ALLOW_UNALIGNED_TRUETYPE
+
+#define ttBYTE(p) (* (stbtt_uint8 *) (p))
+#define ttCHAR(p) (* (stbtt_int8 *) (p))
+#define ttFixed(p) ttLONG(p)
+
+#if defined(STB_TRUETYPE_BIGENDIAN) && !defined(ALLOW_UNALIGNED_TRUETYPE)
+
+ #define ttUSHORT(p) (* (stbtt_uint16 *) (p))
+ #define ttSHORT(p) (* (stbtt_int16 *) (p))
+ #define ttULONG(p) (* (stbtt_uint32 *) (p))
+ #define ttLONG(p) (* (stbtt_int32 *) (p))
+
+#else
+
+ stbtt_uint16 ttUSHORT(const stbtt_uint8 *p) { return p[0]*256 + p[1]; }
+ stbtt_int16 ttSHORT(const stbtt_uint8 *p) { return p[0]*256 + p[1]; }
+ stbtt_uint32 ttULONG(const stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }
+ stbtt_int32 ttLONG(const stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }
+
+#endif
+
+#define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3))
+#define stbtt_tag(p,str) stbtt_tag4(p,str[0],str[1],str[2],str[3])
+
+static int stbtt__isfont(const stbtt_uint8 *font)
+{
+ // check the version number
+ if (stbtt_tag4(font, '1',0,0,0)) return 1; // TrueType 1
+ if (stbtt_tag(font, "typ1")) return 1; // TrueType with type 1 font -- we don't support this!
+ if (stbtt_tag(font, "OTTO")) return 1; // OpenType with CFF
+ if (stbtt_tag4(font, 0,1,0,0)) return 1; // OpenType 1.0
+ return 0;
+}
+
+// @OPTIMIZE: binary search
+static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag)
+{
+ stbtt_int32 num_tables = ttUSHORT(data+fontstart+4);
+ stbtt_uint32 tabledir = fontstart + 12;
+ stbtt_int32 i;
+ for (i=0; i < num_tables; ++i) {
+ stbtt_uint32 loc = tabledir + 16*i;
+ if (stbtt_tag(data+loc+0, tag))
+ return ttULONG(data+loc+8);
+ }
+ return 0;
+}
+
+int stbtt_GetFontOffsetForIndex(const unsigned char *font_collection, int index)
+{
+ // if it's just a font, there's only one valid index
+ if (stbtt__isfont(font_collection))
+ return index == 0 ? 0 : -1;
+
+ // check if it's a TTC
+ if (stbtt_tag(font_collection, "ttcf")) {
+ // version 1?
+ if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) {
+ stbtt_int32 n = ttLONG(font_collection+8);
+ if (index >= n)
+ return -1;
+ return ttULONG(font_collection+12+index*14);
+ }
+ }
+ return -1;
+}
+
+int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data2, int fontstart)
+{
+ stbtt_uint8 *data = (stbtt_uint8 *) data2;
+ stbtt_uint32 cmap, t;
+ stbtt_int32 i,numTables;
+
+ info->data = data;
+ info->fontstart = fontstart;
+
+ cmap = stbtt__find_table(data, fontstart, "cmap"); // required
+ info->loca = stbtt__find_table(data, fontstart, "loca"); // required
+ info->head = stbtt__find_table(data, fontstart, "head"); // required
+ info->glyf = stbtt__find_table(data, fontstart, "glyf"); // required
+ info->hhea = stbtt__find_table(data, fontstart, "hhea"); // required
+ info->hmtx = stbtt__find_table(data, fontstart, "hmtx"); // required
+ info->kern = stbtt__find_table(data, fontstart, "kern"); // not required
+ if (!cmap || !info->loca || !info->head || !info->glyf || !info->hhea || !info->hmtx)
+ return 0;
+
+ t = stbtt__find_table(data, fontstart, "maxp");
+ if (t)
+ info->numGlyphs = ttUSHORT(data+t+4);
+ else
+ info->numGlyphs = 0xffff;
+
+ // find a cmap encoding table we understand *now* to avoid searching
+ // later. (todo: could make this installable)
+ // the same regardless of glyph.
+ numTables = ttUSHORT(data + cmap + 2);
+ info->index_map = 0;
+ for (i=0; i < numTables; ++i) {
+ stbtt_uint32 encoding_record = cmap + 4 + 8 * i;
+ // find an encoding we understand:
+ switch(ttUSHORT(data+encoding_record)) {
+ case STBTT_PLATFORM_ID_MICROSOFT:
+ switch (ttUSHORT(data+encoding_record+2)) {
+ case STBTT_MS_EID_UNICODE_BMP:
+ case STBTT_MS_EID_UNICODE_FULL:
+ // MS/Unicode
+ info->index_map = cmap + ttULONG(data+encoding_record+4);
+ break;
+ }
+ break;
+ }
+ }
+ if (info->index_map == 0)
+ return 0;
+
+ info->indexToLocFormat = ttUSHORT(data+info->head + 50);
+ return 1;
+}
+
+int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint)
+{
+ stbtt_uint8 *data = info->data;
+ stbtt_uint32 index_map = info->index_map;
+
+ stbtt_uint16 format = ttUSHORT(data + index_map + 0);
+ if (format == 0) { // apple byte encoding
+ stbtt_int32 bytes = ttUSHORT(data + index_map + 2);
+ if (unicode_codepoint < bytes-6)
+ return ttBYTE(data + index_map + 6 + unicode_codepoint);
+ return 0;
+ } else if (format == 6) {
+ stbtt_uint32 first = ttUSHORT(data + index_map + 6);
+ stbtt_uint32 count = ttUSHORT(data + index_map + 8);
+ if ((stbtt_uint32) unicode_codepoint >= first && (stbtt_uint32) unicode_codepoint < first+count)
+ return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first)*2);
+ return 0;
+ } else if (format == 2) {
+ STBTT_assert(0); // @TODO: high-byte mapping for japanese/chinese/korean
+ return 0;
+ } else if (format == 4) { // standard mapping for windows fonts: binary search collection of ranges
+ stbtt_uint16 segcount = ttUSHORT(data+index_map+6) >> 1;
+ stbtt_uint16 searchRange = ttUSHORT(data+index_map+8) >> 1;
+ stbtt_uint16 entrySelector = ttUSHORT(data+index_map+10);
+ stbtt_uint16 rangeShift = ttUSHORT(data+index_map+12) >> 1;
+ stbtt_uint16 item, offset, start, end;
+
+ // do a binary search of the segments
+ stbtt_uint32 endCount = index_map + 14;
+ stbtt_uint32 search = endCount;
+
+ if (unicode_codepoint > 0xffff)
+ return 0;
+
+ // they lie from endCount .. endCount + segCount
+ // but searchRange is the nearest power of two, so...
+ if (unicode_codepoint >= ttUSHORT(data + search + rangeShift*2))
+ search += rangeShift*2;
+
+ // now decrement to bias correctly to find smallest
+ search -= 2;
+ while (entrySelector) {
+ searchRange >>= 1;
+ start = ttUSHORT(data + search + 2 + segcount*2 + 2);
+ end = ttUSHORT(data + search + 2);
+ start = ttUSHORT(data + search + searchRange*2 + segcount*2 + 2);
+ end = ttUSHORT(data + search + searchRange*2);
+ if (unicode_codepoint > end)
+ search += searchRange*2;
+ --entrySelector;
+ }
+ search += 2;
+
+ item = (stbtt_uint16) ((search - endCount) >> 1);
+
+ STBTT_assert(unicode_codepoint <= ttUSHORT(data + endCount + 2*item));
+ start = ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item);
+ end = ttUSHORT(data + index_map + 14 + 2 + 2*item);
+ if (unicode_codepoint < start)
+ return 0;
+
+ offset = ttUSHORT(data + index_map + 14 + segcount*6 + 2 + 2*item);
+ if (offset == 0)
+ return (stbtt_uint16) (unicode_codepoint + ttSHORT(data + index_map + 14 + segcount*4 + 2 + 2*item));
+
+ return ttUSHORT(data + offset + (unicode_codepoint-start)*2 + index_map + 14 + segcount*6 + 2 + 2*item);
+ } else if (format == 12 || format == 13) {
+ stbtt_uint32 ngroups = ttULONG(data+index_map+12);
+ stbtt_int32 low,high;
+ low = 0; high = (stbtt_int32)ngroups;
+ // Binary search the right group.
+ while (low < high) {
+ stbtt_int32 mid = low + ((high-low) >> 1); // rounds down, so low <= mid < high
+ stbtt_uint32 start_char = ttULONG(data+index_map+16+mid*12);
+ stbtt_uint32 end_char = ttULONG(data+index_map+16+mid*12+4);
+ if ((stbtt_uint32) unicode_codepoint < start_char)
+ high = mid;
+ else if ((stbtt_uint32) unicode_codepoint > end_char)
+ low = mid+1;
+ else {
+ stbtt_uint32 start_glyph = ttULONG(data+index_map+16+mid*12+8);
+ if (format == 12)
+ return start_glyph + unicode_codepoint-start_char;
+ else // format == 13
+ return start_glyph;
+ }
+ }
+ return 0; // not found
+ }
+ // @TODO
+ STBTT_assert(0);
+ return 0;
+}
+
+int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices)
+{
+ return stbtt_GetGlyphShape(info, stbtt_FindGlyphIndex(info, unicode_codepoint), vertices);
+}
+
+static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy)
+{
+ v->type = type;
+ v->x = (stbtt_int16) x;
+ v->y = (stbtt_int16) y;
+ v->cx = (stbtt_int16) cx;
+ v->cy = (stbtt_int16) cy;
+}
+
+static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index)
+{
+ int g1,g2;
+
+ if (glyph_index >= info->numGlyphs) return -1; // glyph index out of range
+ if (info->indexToLocFormat >= 2) return -1; // unknown index->glyph map format
+
+ if (info->indexToLocFormat == 0) {
+ g1 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2) * 2;
+ g2 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2 + 2) * 2;
+ } else {
+ g1 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4);
+ g2 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4 + 4);
+ }
+
+ return g1==g2 ? -1 : g1; // if length is 0, return -1
+}
+
+int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
+{
+ int g = stbtt__GetGlyfOffset(info, glyph_index);
+ if (g < 0) return 0;
+
+ if (x0) *x0 = ttSHORT(info->data + g + 2);
+ if (y0) *y0 = ttSHORT(info->data + g + 4);
+ if (x1) *x1 = ttSHORT(info->data + g + 6);
+ if (y1) *y1 = ttSHORT(info->data + g + 8);
+ return 1;
+}
+
+int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1)
+{
+ return stbtt_GetGlyphBox(info, stbtt_FindGlyphIndex(info,codepoint), x0,y0,x1,y1);
+}
+
+int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index)
+{
+ stbtt_int16 numberOfContours;
+ int g = stbtt__GetGlyfOffset(info, glyph_index);
+ if (g < 0) return 1;
+ numberOfContours = ttSHORT(info->data + g);
+ return numberOfContours == 0;
+}
+
+static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off,
+ stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy)
+{
+ if (start_off) {
+ if (was_off)
+ stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+scx)>>1, (cy+scy)>>1, cx,cy);
+ stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx,sy,scx,scy);
+ } else {
+ if (was_off)
+ stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve,sx,sy,cx,cy);
+ else
+ stbtt_setvertex(&vertices[num_vertices++], STBTT_vline,sx,sy,0,0);
+ }
+ return num_vertices;
+}
+
+int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)
+{
+ stbtt_int16 numberOfContours;
+ stbtt_uint8 *endPtsOfContours;
+ stbtt_uint8 *data = info->data;
+ stbtt_vertex *vertices=0;
+ int num_vertices=0;
+ int g = stbtt__GetGlyfOffset(info, glyph_index);
+
+ *pvertices = NULL;
+
+ if (g < 0) return 0;
+
+ numberOfContours = ttSHORT(data + g);
+
+ if (numberOfContours > 0) {
+ stbtt_uint8 flags=0,flagcount;
+ stbtt_int32 ins, i,j=0,m,n, next_move, was_off=0, off, start_off=0;
+ stbtt_int32 x,y,cx,cy,sx,sy, scx,scy;
+ stbtt_uint8 *points;
+ endPtsOfContours = (data + g + 10);
+ ins = ttUSHORT(data + g + 10 + numberOfContours * 2);
+ points = data + g + 10 + numberOfContours * 2 + 2 + ins;
+
+ n = 1+ttUSHORT(endPtsOfContours + numberOfContours*2-2);
+
+ m = n + 2*numberOfContours; // a loose bound on how many vertices we might need
+ vertices = (stbtt_vertex *) STBTT_malloc(m * sizeof(vertices[0]), info->userdata);
+ if (vertices == 0)
+ return 0;
+
+ next_move = 0;
+ flagcount=0;
+
+ // in first pass, we load uninterpreted data into the allocated array
+ // above, shifted to the end of the array so we won't overwrite it when
+ // we create our final data starting from the front
+
+ off = m - n; // starting offset for uninterpreted data, regardless of how m ends up being calculated
+
+ // first load flags
+
+ for (i=0; i < n; ++i) {
+ if (flagcount == 0) {
+ flags = *points++;
+ if (flags & 8)
+ flagcount = *points++;
+ } else
+ --flagcount;
+ vertices[off+i].type = flags;
+ }
+
+ // now load x coordinates
+ x=0;
+ for (i=0; i < n; ++i) {
+ flags = vertices[off+i].type;
+ if (flags & 2) {
+ stbtt_int16 dx = *points++;
+ x += (flags & 16) ? dx : -dx; // ???
+ } else {
+ if (!(flags & 16)) {
+ x = x + (stbtt_int16) (points[0]*256 + points[1]);
+ points += 2;
+ }
+ }
+ vertices[off+i].x = (stbtt_int16) x;
+ }
+
+ // now load y coordinates
+ y=0;
+ for (i=0; i < n; ++i) {
+ flags = vertices[off+i].type;
+ if (flags & 4) {
+ stbtt_int16 dy = *points++;
+ y += (flags & 32) ? dy : -dy; // ???
+ } else {
+ if (!(flags & 32)) {
+ y = y + (stbtt_int16) (points[0]*256 + points[1]);
+ points += 2;
+ }
+ }
+ vertices[off+i].y = (stbtt_int16) y;
+ }
+
+ // now convert them to our format
+ num_vertices=0;
+ sx = sy = cx = cy = scx = scy = 0;
+ for (i=0; i < n; ++i) {
+ flags = vertices[off+i].type;
+ x = (stbtt_int16) vertices[off+i].x;
+ y = (stbtt_int16) vertices[off+i].y;
+
+ if (next_move == i) {
+ if (i != 0)
+ num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy);
+
+ // now start the new one
+ start_off = !(flags & 1);
+ if (start_off) {
+ // if we start off with an off-curve point, then when we need to find a point on the curve
+ // where we can start, and we need to save some state for when we wraparound.
+ scx = x;
+ scy = y;
+ if (!(vertices[off+i+1].type & 1)) {
+ // next point is also a curve point, so interpolate an on-point curve
+ sx = (x + (stbtt_int32) vertices[off+i+1].x) >> 1;
+ sy = (y + (stbtt_int32) vertices[off+i+1].y) >> 1;
+ } else {
+ // otherwise just use the next point as our start point
+ sx = (stbtt_int32) vertices[off+i+1].x;
+ sy = (stbtt_int32) vertices[off+i+1].y;
+ ++i; // we're using point i+1 as the starting point, so skip it
+ }
+ } else {
+ sx = x;
+ sy = y;
+ }
+ stbtt_setvertex(&vertices[num_vertices++], STBTT_vmove,sx,sy,0,0);
+ was_off = 0;
+ next_move = 1 + ttUSHORT(endPtsOfContours+j*2);
+ ++j;
+ } else {
+ if (!(flags & 1)) { // if it's a curve
+ if (was_off) // two off-curve control points in a row means interpolate an on-curve midpoint
+ stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+x)>>1, (cy+y)>>1, cx, cy);
+ cx = x;
+ cy = y;
+ was_off = 1;
+ } else {
+ if (was_off)
+ stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, x,y, cx, cy);
+ else
+ stbtt_setvertex(&vertices[num_vertices++], STBTT_vline, x,y,0,0);
+ was_off = 0;
+ }
+ }
+ }
+ num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy);
+ } else if (numberOfContours == -1) {
+ // Compound shapes.
+ int more = 1;
+ stbtt_uint8 *comp = data + g + 10;
+ num_vertices = 0;
+ vertices = 0;
+ while (more) {
+ stbtt_uint16 flags, gidx;
+ int comp_num_verts = 0, i;
+ stbtt_vertex *comp_verts = 0, *tmp = 0;
+ float mtx[6] = {1,0,0,1,0,0}, m, n;
+
+ flags = ttSHORT(comp); comp+=2;
+ gidx = ttSHORT(comp); comp+=2;
+
+ if (flags & 2) { // XY values
+ if (flags & 1) { // shorts
+ mtx[4] = ttSHORT(comp); comp+=2;
+ mtx[5] = ttSHORT(comp); comp+=2;
+ } else {
+ mtx[4] = ttCHAR(comp); comp+=1;
+ mtx[5] = ttCHAR(comp); comp+=1;
+ }
+ }
+ else {
+ // @TODO handle matching point
+ STBTT_assert(0);
+ }
+ if (flags & (1<<3)) { // WE_HAVE_A_SCALE
+ mtx[0] = mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
+ mtx[1] = mtx[2] = 0;
+ } else if (flags & (1<<6)) { // WE_HAVE_AN_X_AND_YSCALE
+ mtx[0] = ttSHORT(comp)/16384.0f; comp+=2;
+ mtx[1] = mtx[2] = 0;
+ mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
+ } else if (flags & (1<<7)) { // WE_HAVE_A_TWO_BY_TWO
+ mtx[0] = ttSHORT(comp)/16384.0f; comp+=2;
+ mtx[1] = ttSHORT(comp)/16384.0f; comp+=2;
+ mtx[2] = ttSHORT(comp)/16384.0f; comp+=2;
+ mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
+ }
+
+ // Find transformation scales.
+ m = (float) sqrt(mtx[0]*mtx[0] + mtx[1]*mtx[1]);
+ n = (float) sqrt(mtx[2]*mtx[2] + mtx[3]*mtx[3]);
+
+ // Get indexed glyph.
+ comp_num_verts = stbtt_GetGlyphShape(info, gidx, &comp_verts);
+ if (comp_num_verts > 0) {
+ // Transform vertices.
+ for (i = 0; i < comp_num_verts; ++i) {
+ stbtt_vertex* v = &comp_verts[i];
+ stbtt_vertex_type x,y;
+ x=v->x; y=v->y;
+ v->x = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4]));
+ v->y = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5]));
+ x=v->cx; y=v->cy;
+ v->cx = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4]));
+ v->cy = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5]));
+ }
+ // Append vertices.
+ tmp = (stbtt_vertex*)STBTT_malloc((num_vertices+comp_num_verts)*sizeof(stbtt_vertex), info->userdata);
+ if (!tmp) {
+ if (vertices) STBTT_free(vertices, info->userdata);
+ if (comp_verts) STBTT_free(comp_verts, info->userdata);
+ return 0;
+ }
+ if (num_vertices > 0) memcpy(tmp, vertices, num_vertices*sizeof(stbtt_vertex));
+ memcpy(tmp+num_vertices, comp_verts, comp_num_verts*sizeof(stbtt_vertex));
+ if (vertices) STBTT_free(vertices, info->userdata);
+ vertices = tmp;
+ STBTT_free(comp_verts, info->userdata);
+ num_vertices += comp_num_verts;
+ }
+ // More components ?
+ more = flags & (1<<5);
+ }
+ } else if (numberOfContours < 0) {
+ // @TODO other compound variations?
+ STBTT_assert(0);
+ } else {
+ // numberOfCounters == 0, do nothing
+ }
+
+ *pvertices = vertices;
+ return num_vertices;
+}
+
+void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing)
+{
+ stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34);
+ if (glyph_index < numOfLongHorMetrics) {
+ if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*glyph_index);
+ if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*glyph_index + 2);
+ } else {
+ if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*(numOfLongHorMetrics-1));
+ if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics));
+ }
+}
+
+int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)
+{
+ stbtt_uint8 *data = info->data + info->kern;
+ stbtt_uint32 needle, straw;
+ int l, r, m;
+
+ // we only look at the first table. it must be 'horizontal' and format 0.
+ if (!info->kern)
+ return 0;
+ if (ttUSHORT(data+2) < 1) // number of tables, need at least 1
+ return 0;
+ if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format
+ return 0;
+
+ l = 0;
+ r = ttUSHORT(data+10) - 1;
+ needle = glyph1 << 16 | glyph2;
+ while (l <= r) {
+ m = (l + r) >> 1;
+ straw = ttULONG(data+18+(m*6)); // note: unaligned read
+ if (needle < straw)
+ r = m - 1;
+ else if (needle > straw)
+ l = m + 1;
+ else
+ return ttSHORT(data+22+(m*6));
+ }
+ return 0;
+}
+
+int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2)
+{
+ if (!info->kern) // if no kerning table, don't waste time looking up both codepoint->glyphs
+ return 0;
+ return stbtt_GetGlyphKernAdvance(info, stbtt_FindGlyphIndex(info,ch1), stbtt_FindGlyphIndex(info,ch2));
+}
+
+void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing)
+{
+ stbtt_GetGlyphHMetrics(info, stbtt_FindGlyphIndex(info,codepoint), advanceWidth, leftSideBearing);
+}
+
+void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap)
+{
+ if (ascent ) *ascent = ttSHORT(info->data+info->hhea + 4);
+ if (descent) *descent = ttSHORT(info->data+info->hhea + 6);
+ if (lineGap) *lineGap = ttSHORT(info->data+info->hhea + 8);
+}
+
+void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1)
+{
+ *x0 = ttSHORT(info->data + info->head + 36);
+ *y0 = ttSHORT(info->data + info->head + 38);
+ *x1 = ttSHORT(info->data + info->head + 40);
+ *y1 = ttSHORT(info->data + info->head + 42);
+}
+
+float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height)
+{
+ int fheight = ttSHORT(info->data + info->hhea + 4) - ttSHORT(info->data + info->hhea + 6);
+ return (float) height / fheight;
+}
+
+float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels)
+{
+ int unitsPerEm = ttUSHORT(info->data + info->head + 18);
+ return pixels / unitsPerEm;
+}
+
+void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v)
+{
+ STBTT_free(v, info->userdata);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// antialiasing software rasterizer
+//
+
+void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+ int x0,y0,x1,y1;
+ if (!stbtt_GetGlyphBox(font, glyph, &x0,&y0,&x1,&y1))
+ x0=y0=x1=y1=0; // e.g. space character
+ // now move to integral bboxes (treating pixels as little squares, what pixels get touched)?
+ if (ix0) *ix0 = STBTT_ifloor(x0 * scale_x + shift_x);
+ if (iy0) *iy0 = -STBTT_iceil (y1 * scale_y + shift_y);
+ if (ix1) *ix1 = STBTT_iceil (x1 * scale_x + shift_x);
+ if (iy1) *iy1 = -STBTT_ifloor(y0 * scale_y + shift_y);
+}
+void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+ stbtt_GetGlyphBitmapBoxSubpixel(font, glyph, scale_x, scale_y,0.0f,0.0f, ix0, iy0, ix1, iy1);
+}
+
+void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+ stbtt_GetGlyphBitmapBoxSubpixel(font, stbtt_FindGlyphIndex(font,codepoint), scale_x, scale_y,shift_x,shift_y, ix0,iy0,ix1,iy1);
+}
+
+void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+ stbtt_GetCodepointBitmapBoxSubpixel(font, codepoint, scale_x, scale_y,0.0f,0.0f, ix0,iy0,ix1,iy1);
+}
+
+typedef struct stbtt__edge {
+ float x0,y0, x1,y1;
+ int invert;
+} stbtt__edge;
+
+typedef struct stbtt__active_edge
+{
+ int x,dx;
+ float ey;
+ struct stbtt__active_edge *next;
+ int valid;
+} stbtt__active_edge;
+
+#define FIXSHIFT 10
+#define FIX (1 << FIXSHIFT)
+#define FIXMASK (FIX-1)
+
+static stbtt__active_edge *new_active(stbtt__edge *e, int off_x, float start_point, void *userdata)
+{
+ stbtt__active_edge *z = (stbtt__active_edge *) STBTT_malloc(sizeof(*z), userdata); // @TODO: make a pool of these!!!
+ float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
+ STBTT_assert(e->y0 <= start_point);
+ if (!z) return z;
+ // round dx down to avoid going too far
+ if (dxdy < 0)
+ z->dx = -STBTT_ifloor(FIX * -dxdy);
+ else
+ z->dx = STBTT_ifloor(FIX * dxdy);
+ z->x = STBTT_ifloor(FIX * (e->x0 + dxdy * (start_point - e->y0)));
+ z->x -= off_x * FIX;
+ z->ey = e->y1;
+ z->next = 0;
+ z->valid = e->invert ? 1 : -1;
+ return z;
+}
+
+// note: this routine clips fills that extend off the edges... ideally this
+// wouldn't happen, but it could happen if the truetype glyph bounding boxes
+// are wrong, or if the user supplies a too-small bitmap
+static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight)
+{
+ // non-zero winding fill
+ int x0=0, w=0;
+
+ while (e) {
+ if (w == 0) {
+ // if we're currently at zero, we need to record the edge start point
+ x0 = e->x; w += e->valid;
+ } else {
+ int x1 = e->x; w += e->valid;
+ // if we went to zero, we need to draw
+ if (w == 0) {
+ int i = x0 >> FIXSHIFT;
+ int j = x1 >> FIXSHIFT;
+
+ if (i < len && j >= 0) {
+ if (i == j) {
+ // x0,x1 are the same pixel, so compute combined coverage
+ scanline[i] = scanline[i] + (stbtt_uint8) ((x1 - x0) * max_weight >> FIXSHIFT);
+ } else {
+ if (i >= 0) // add antialiasing for x0
+ scanline[i] = scanline[i] + (stbtt_uint8) (((FIX - (x0 & FIXMASK)) * max_weight) >> FIXSHIFT);
+ else
+ i = -1; // clip
+
+ if (j < len) // add antialiasing for x1
+ scanline[j] = scanline[j] + (stbtt_uint8) (((x1 & FIXMASK) * max_weight) >> FIXSHIFT);
+ else
+ j = len; // clip
+
+ for (++i; i < j; ++i) // fill pixels between x0 and x1
+ scanline[i] = scanline[i] + (stbtt_uint8) max_weight;
+ }
+ }
+ }
+ }
+
+ e = e->next;
+ }
+}
+
+static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata)
+{
+ stbtt__active_edge *active = NULL;
+ int y,j=0;
+ int max_weight = (255 / vsubsample); // weight per vertical scanline
+ int s; // vertical subsample index
+ unsigned char scanline_data[512], *scanline;
+
+ if (result->w > 512)
+ scanline = (unsigned char *) STBTT_malloc(result->w, userdata);
+ else
+ scanline = scanline_data;
+
+ y = off_y * vsubsample;
+ e[n].y0 = (off_y + result->h) * (float) vsubsample + 1;
+
+ while (j < result->h) {
+ STBTT_memset(scanline, 0, result->w);
+ for (s=0; s < vsubsample; ++s) {
+ // find center of pixel for this scanline
+ float scan_y = y + 0.5f;
+ stbtt__active_edge **step = &active;
+
+ // update all active edges;
+ // remove all active edges that terminate before the center of this scanline
+ while (*step) {
+ stbtt__active_edge * z = *step;
+ if (z->ey <= scan_y) {
+ *step = z->next; // delete from list
+ STBTT_assert(z->valid);
+ z->valid = 0;
+ STBTT_free(z, userdata);
+ } else {
+ z->x += z->dx; // advance to position for current scanline
+ step = &((*step)->next); // advance through list
+ }
+ }
+
+ // resort the list if needed
+ for(;;) {
+ int changed=0;
+ step = &active;
+ while (*step && (*step)->next) {
+ if ((*step)->x > (*step)->next->x) {
+ stbtt__active_edge *t = *step;
+ stbtt__active_edge *q = t->next;
+
+ t->next = q->next;
+ q->next = t;
+ *step = q;
+ changed = 1;
+ }
+ step = &(*step)->next;
+ }
+ if (!changed) break;
+ }
+
+ // insert all edges that start before the center of this scanline -- omit ones that also end on this scanline
+ while (e->y0 <= scan_y) {
+ if (e->y1 > scan_y) {
+ stbtt__active_edge *z = new_active(e, off_x, scan_y, userdata);
+ // find insertion point
+ if (active == NULL)
+ active = z;
+ else if (z->x < active->x) {
+ // insert at front
+ z->next = active;
+ active = z;
+ } else {
+ // find thing to insert AFTER
+ stbtt__active_edge *p = active;
+ while (p->next && p->next->x < z->x)
+ p = p->next;
+ // at this point, p->next->x is NOT < z->x
+ z->next = p->next;
+ p->next = z;
+ }
+ }
+ ++e;
+ }
+
+ // now process all active edges in XOR fashion
+ if (active)
+ stbtt__fill_active_edges(scanline, result->w, active, max_weight);
+
+ ++y;
+ }
+ STBTT_memcpy(result->pixels + j * result->stride, scanline, result->w);
+ ++j;
+ }
+
+ while (active) {
+ stbtt__active_edge *z = active;
+ active = active->next;
+ STBTT_free(z, userdata);
+ }
+
+ if (scanline != scanline_data)
+ STBTT_free(scanline, userdata);
+}
+
+static int stbtt__edge_compare(const void *p, const void *q)
+{
+ stbtt__edge *a = (stbtt__edge *) p;
+ stbtt__edge *b = (stbtt__edge *) q;
+
+ if (a->y0 < b->y0) return -1;
+ if (a->y0 > b->y0) return 1;
+ return 0;
+}
+
+typedef struct
+{
+ float x,y;
+} stbtt__point;
+
+static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, float scale_x, float scale_y, float shift_x, float shift_y, int off_x, int off_y, int invert, void *userdata)
+{
+ float y_scale_inv = invert ? -scale_y : scale_y;
+ stbtt__edge *e;
+ int n,i,j,k,m;
+ int vsubsample = result->h < 8 ? 15 : 5;
+ // vsubsample should divide 255 evenly; otherwise we won't reach full opacity
+
+ // now we have to blow out the windings into explicit edge lists
+ n = 0;
+ for (i=0; i < windings; ++i)
+ n += wcount[i];
+
+ e = (stbtt__edge *) STBTT_malloc(sizeof(*e) * (n+1), userdata); // add an extra one as a sentinel
+ if (e == 0) return;
+ n = 0;
+
+ m=0;
+ for (i=0; i < windings; ++i) {
+ stbtt__point *p = pts + m;
+ m += wcount[i];
+ j = wcount[i]-1;
+ for (k=0; k < wcount[i]; j=k++) {
+ int a=k,b=j;
+ // skip the edge if horizontal
+ if (p[j].y == p[k].y)
+ continue;
+ // add edge from j to k to the list
+ e[n].invert = 0;
+ if (invert ? p[j].y > p[k].y : p[j].y < p[k].y) {
+ e[n].invert = 1;
+ a=j,b=k;
+ }
+ e[n].x0 = p[a].x * scale_x + shift_x;
+ e[n].y0 = p[a].y * y_scale_inv * vsubsample + shift_y;
+ e[n].x1 = p[b].x * scale_x + shift_x;
+ e[n].y1 = p[b].y * y_scale_inv * vsubsample + shift_y;
+ ++n;
+ }
+ }
+
+ // now sort the edges by their highest point (should snap to integer, and then by x)
+ STBTT_sort(e, n, sizeof(e[0]), stbtt__edge_compare);
+
+ // now, traverse the scanlines and find the intersections on each scanline, use xor winding rule
+ stbtt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, userdata);
+
+ STBTT_free(e, userdata);
+}
+
+static void stbtt__add_point(stbtt__point *points, int n, float x, float y)
+{
+ if (!points) return; // during first pass, it's unallocated
+ points[n].x = x;
+ points[n].y = y;
+}
+
+// tesselate until threshhold p is happy... @TODO warped to compensate for non-linear stretching
+static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n)
+{
+ // midpoint
+ float mx = (x0 + 2*x1 + x2)/4;
+ float my = (y0 + 2*y1 + y2)/4;
+ // versus directly drawn line
+ float dx = (x0+x2)/2 - mx;
+ float dy = (y0+y2)/2 - my;
+ if (n > 16) // 65536 segments on one curve better be enough!
+ return 1;
+ if (dx*dx+dy*dy > objspace_flatness_squared) { // half-pixel error allowed... need to be smaller if AA
+ stbtt__tesselate_curve(points, num_points, x0,y0, (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1);
+ stbtt__tesselate_curve(points, num_points, mx,my, (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1);
+ } else {
+ stbtt__add_point(points, *num_points,x2,y2);
+ *num_points = *num_points+1;
+ }
+ return 1;
+}
+
+// returns number of contours
+stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata)
+{
+ stbtt__point *points=0;
+ int num_points=0;
+
+ float objspace_flatness_squared = objspace_flatness * objspace_flatness;
+ int i,n=0,start=0, pass;
+
+ // count how many "moves" there are to get the contour count
+ for (i=0; i < num_verts; ++i)
+ if (vertices[i].type == STBTT_vmove)
+ ++n;
+
+ *num_contours = n;
+ if (n == 0) return 0;
+
+ *contour_lengths = (int *) STBTT_malloc(sizeof(**contour_lengths) * n, userdata);
+
+ if (*contour_lengths == 0) {
+ *num_contours = 0;
+ return 0;
+ }
+
+ // make two passes through the points so we don't need to realloc
+ for (pass=0; pass < 2; ++pass) {
+ float x=0,y=0;
+ if (pass == 1) {
+ points = (stbtt__point *) STBTT_malloc(num_points * sizeof(points[0]), userdata);
+ if (points == NULL) goto error;
+ }
+ num_points = 0;
+ n= -1;
+ for (i=0; i < num_verts; ++i) {
+ switch (vertices[i].type) {
+ case STBTT_vmove:
+ // start the next contour
+ if (n >= 0)
+ (*contour_lengths)[n] = num_points - start;
+ ++n;
+ start = num_points;
+
+ x = vertices[i].x, y = vertices[i].y;
+ stbtt__add_point(points, num_points++, x,y);
+ break;
+ case STBTT_vline:
+ x = vertices[i].x, y = vertices[i].y;
+ stbtt__add_point(points, num_points++, x, y);
+ break;
+ case STBTT_vcurve:
+ stbtt__tesselate_curve(points, &num_points, x,y,
+ vertices[i].cx, vertices[i].cy,
+ vertices[i].x, vertices[i].y,
+ objspace_flatness_squared, 0);
+ x = vertices[i].x, y = vertices[i].y;
+ break;
+ }
+ }
+ (*contour_lengths)[n] = num_points - start;
+ }
+
+ return points;
+error:
+ STBTT_free(points, userdata);
+ STBTT_free(*contour_lengths, userdata);
+ *contour_lengths = 0;
+ *num_contours = 0;
+ return NULL;
+}
+
+void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata)
+{
+ float scale = scale_x > scale_y ? scale_y : scale_x;
+ int winding_count, *winding_lengths;
+ stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata);
+ if (windings) {
+ stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, userdata);
+ STBTT_free(winding_lengths, userdata);
+ STBTT_free(windings, userdata);
+ }
+}
+
+void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata)
+{
+ STBTT_free(bitmap, userdata);
+}
+
+unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff)
+{
+ int ix0,iy0,ix1,iy1;
+ stbtt__bitmap gbm;
+ stbtt_vertex *vertices;
+ int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
+
+ if (scale_x == 0) scale_x = scale_y;
+ if (scale_y == 0) {
+ if (scale_x == 0) return NULL;
+ scale_y = scale_x;
+ }
+
+ stbtt_GetGlyphBitmapBox(info, glyph, scale_x, scale_y, &ix0,&iy0,&ix1,&iy1);
+
+ // now we get the size
+ gbm.w = (ix1 - ix0);
+ gbm.h = (iy1 - iy0);
+ gbm.pixels = NULL; // in case we error
+
+ if (width ) *width = gbm.w;
+ if (height) *height = gbm.h;
+ if (xoff ) *xoff = ix0;
+ if (yoff ) *yoff = iy0;
+
+ if (gbm.w && gbm.h) {
+ gbm.pixels = (unsigned char *) STBTT_malloc(gbm.w * gbm.h, info->userdata);
+ if (gbm.pixels) {
+ gbm.stride = gbm.w;
+
+ stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0, iy0, 1, info->userdata);
+ }
+ }
+ STBTT_free(vertices, info->userdata);
+ return gbm.pixels;
+}
+
+unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff)
+{
+ return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y, 0.0f, 0.0f, glyph, width, height, xoff, yoff);
+}
+
+void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph)
+{
+ int ix0,iy0;
+ stbtt_vertex *vertices;
+ int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
+ stbtt__bitmap gbm;
+
+ stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,0,0);
+ gbm.pixels = output;
+ gbm.w = out_w;
+ gbm.h = out_h;
+ gbm.stride = out_stride;
+
+ if (gbm.w && gbm.h)
+ stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0,iy0, 1, info->userdata);
+
+ STBTT_free(vertices, info->userdata);
+}
+
+void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph)
+{
+ stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, glyph);
+}
+
+unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff)
+{
+ return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y,shift_x,shift_y, stbtt_FindGlyphIndex(info,codepoint), width,height,xoff,yoff);
+}
+
+void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint)
+{
+ stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, stbtt_FindGlyphIndex(info,codepoint));
+}
+
+unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff)
+{
+ return stbtt_GetCodepointBitmapSubpixel(info, scale_x, scale_y, 0.0f,0.0f, codepoint, width,height,xoff,yoff);
+}
+
+void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint)
+{
+ stbtt_MakeCodepointBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, codepoint);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// bitmap baking
+//
+// This is SUPER-CRAPPY packing to keep source code small
+
+extern int stbtt_BakeFontBitmap(const unsigned char *data, int offset, // font location (use offset=0 for plain .ttf)
+ float pixel_height, // height of font in pixels
+ unsigned char *pixels, int pw, int ph, // bitmap to be filled in
+ int first_char, int num_chars, // characters to bake
+ stbtt_bakedchar *chardata)
+{
+ float scale;
+ int x,y,bottom_y, i;
+ stbtt_fontinfo f;
+ stbtt_InitFont(&f, data, offset);
+ STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels
+ x=y=1;
+ bottom_y = 1;
+
+ scale = stbtt_ScaleForPixelHeight(&f, pixel_height);
+
+ for (i=0; i < num_chars; ++i) {
+ int advance, lsb, x0,y0,x1,y1,gw,gh;
+ int g = stbtt_FindGlyphIndex(&f, first_char + i);
+ stbtt_GetGlyphHMetrics(&f, g, &advance, &lsb);
+ stbtt_GetGlyphBitmapBox(&f, g, scale,scale, &x0,&y0,&x1,&y1);
+ gw = x1-x0;
+ gh = y1-y0;
+ if (x + gw + 1 >= pw)
+ y = bottom_y, x = 1; // advance to next row
+ if (y + gh + 1 >= ph) // check if it fits vertically AFTER potentially moving to next row
+ return -i;
+ STBTT_assert(x+gw < pw);
+ STBTT_assert(y+gh < ph);
+ stbtt_MakeGlyphBitmap(&f, pixels+x+y*pw, gw,gh,pw, scale,scale, g);
+ chardata[i].x0 = (stbtt_int16) x;
+ chardata[i].y0 = (stbtt_int16) y;
+ chardata[i].x1 = (stbtt_int16) (x + gw);
+ chardata[i].y1 = (stbtt_int16) (y + gh);
+ chardata[i].xadvance = scale * advance;
+ chardata[i].xoff = (float) x0;
+ chardata[i].yoff = (float) y0;
+ x = x + gw + 2;
+ if (y+gh+2 > bottom_y)
+ bottom_y = y+gh+2;
+ }
+ return bottom_y;
+}
+
+void stbtt_GetBakedQuad(stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule)
+{
+ float d3d_bias = opengl_fillrule ? 0 : -0.5f;
+ float ipw = 1.0f / pw, iph = 1.0f / ph;
+ stbtt_bakedchar *b = chardata + char_index;
+ int round_x = STBTT_ifloor((*xpos + b->xoff) + 0.5);
+ int round_y = STBTT_ifloor((*ypos + b->yoff) + 0.5);
+
+ q->x0 = round_x + d3d_bias;
+ q->y0 = round_y + d3d_bias;
+ q->x1 = round_x + b->x1 - b->x0 + d3d_bias;
+ q->y1 = round_y + b->y1 - b->y0 + d3d_bias;
+
+ q->s0 = b->x0 * ipw;
+ q->t0 = b->y0 * iph;
+ q->s1 = b->x1 * ipw;
+ q->t1 = b->y1 * iph;
+
+ *xpos += b->xadvance;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// font name matching -- recommended not to use this
+//
+
+// check if a utf8 string contains a prefix which is the utf16 string; if so return length of matching utf8 string
+static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(const stbtt_uint8 *s1, stbtt_int32 len1, const stbtt_uint8 *s2, stbtt_int32 len2)
+{
+ stbtt_int32 i=0;
+
+ // convert utf16 to utf8 and compare the results while converting
+ while (len2) {
+ stbtt_uint16 ch = s2[0]*256 + s2[1];
+ if (ch < 0x80) {
+ if (i >= len1) return -1;
+ if (s1[i++] != ch) return -1;
+ } else if (ch < 0x800) {
+ if (i+1 >= len1) return -1;
+ if (s1[i++] != 0xc0 + (ch >> 6)) return -1;
+ if (s1[i++] != 0x80 + (ch & 0x3f)) return -1;
+ } else if (ch >= 0xd800 && ch < 0xdc00) {
+ stbtt_uint32 c;
+ stbtt_uint16 ch2 = s2[2]*256 + s2[3];
+ if (i+3 >= len1) return -1;
+ c = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000;
+ if (s1[i++] != 0xf0 + (c >> 18)) return -1;
+ if (s1[i++] != 0x80 + ((c >> 12) & 0x3f)) return -1;
+ if (s1[i++] != 0x80 + ((c >> 6) & 0x3f)) return -1;
+ if (s1[i++] != 0x80 + ((c ) & 0x3f)) return -1;
+ s2 += 2; // plus another 2 below
+ len2 -= 2;
+ } else if (ch >= 0xdc00 && ch < 0xe000) {
+ return -1;
+ } else {
+ if (i+2 >= len1) return -1;
+ if (s1[i++] != 0xe0 + (ch >> 12)) return -1;
+ if (s1[i++] != 0x80 + ((ch >> 6) & 0x3f)) return -1;
+ if (s1[i++] != 0x80 + ((ch ) & 0x3f)) return -1;
+ }
+ s2 += 2;
+ len2 -= 2;
+ }
+ return i;
+}
+
+int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2)
+{
+ return len1 == stbtt__CompareUTF8toUTF16_bigendian_prefix((const stbtt_uint8*) s1, len1, (const stbtt_uint8*) s2, len2);
+}
+
+// returns results in whatever encoding you request... but note that 2-byte encodings
+// will be BIG-ENDIAN... use stbtt_CompareUTF8toUTF16_bigendian() to compare
+const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID)
+{
+ stbtt_int32 i,count,stringOffset;
+ stbtt_uint8 *fc = font->data;
+ stbtt_uint32 offset = font->fontstart;
+ stbtt_uint32 nm = stbtt__find_table(fc, offset, "name");
+ if (!nm) return NULL;
+
+ count = ttUSHORT(fc+nm+2);
+ stringOffset = nm + ttUSHORT(fc+nm+4);
+ for (i=0; i < count; ++i) {
+ stbtt_uint32 loc = nm + 6 + 12 * i;
+ if (platformID == ttUSHORT(fc+loc+0) && encodingID == ttUSHORT(fc+loc+2)
+ && languageID == ttUSHORT(fc+loc+4) && nameID == ttUSHORT(fc+loc+6)) {
+ *length = ttUSHORT(fc+loc+8);
+ return (const char *) (fc+stringOffset+ttUSHORT(fc+loc+10));
+ }
+ }
+ return NULL;
+}
+
+static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id)
+{
+ stbtt_int32 i;
+ stbtt_int32 count = ttUSHORT(fc+nm+2);
+ stbtt_int32 stringOffset = nm + ttUSHORT(fc+nm+4);
+
+ for (i=0; i < count; ++i) {
+ stbtt_uint32 loc = nm + 6 + 12 * i;
+ stbtt_int32 id = ttUSHORT(fc+loc+6);
+ if (id == target_id) {
+ // find the encoding
+ stbtt_int32 platform = ttUSHORT(fc+loc+0), encoding = ttUSHORT(fc+loc+2), language = ttUSHORT(fc+loc+4);
+
+ // is this a Unicode encoding?
+ if (platform == 0 || (platform == 3 && encoding == 1) || (platform == 3 && encoding == 10)) {
+ stbtt_int32 slen = ttUSHORT(fc+loc+8), off = ttUSHORT(fc+loc+10);
+
+ // check if there's a prefix match
+ stbtt_int32 matchlen = stbtt__CompareUTF8toUTF16_bigendian_prefix(name, nlen, fc+stringOffset+off,slen);
+ if (matchlen >= 0) {
+ // check for target_id+1 immediately following, with same encoding & language
+ if (i+1 < count && ttUSHORT(fc+loc+12+6) == next_id && ttUSHORT(fc+loc+12) == platform && ttUSHORT(fc+loc+12+2) == encoding && ttUSHORT(fc+loc+12+4) == language) {
+ stbtt_int32 slen = ttUSHORT(fc+loc+12+8), off = ttUSHORT(fc+loc+12+10);
+ if (slen == 0) {
+ if (matchlen == nlen)
+ return 1;
+ } else if (matchlen < nlen && name[matchlen] == ' ') {
+ ++matchlen;
+ if (stbtt_CompareUTF8toUTF16_bigendian((char*) (name+matchlen), nlen-matchlen, (char*)(fc+stringOffset+off),slen))
+ return 1;
+ }
+ } else {
+ // if nothing immediately following
+ if (matchlen == nlen)
+ return 1;
+ }
+ }
+ }
+
+ // @TODO handle other encodings
+ }
+ }
+ return 0;
+}
+
+static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags)
+{
+ stbtt_int32 nlen = (stbtt_int32) STBTT_strlen((char *) name);
+ stbtt_uint32 nm,hd;
+ if (!stbtt__isfont(fc+offset)) return 0;
+
+ // check italics/bold/underline flags in macStyle...
+ if (flags) {
+ hd = stbtt__find_table(fc, offset, "head");
+ if ((ttUSHORT(fc+hd+44) & 7) != (flags & 7)) return 0;
+ }
+
+ nm = stbtt__find_table(fc, offset, "name");
+ if (!nm) return 0;
+
+ if (flags) {
+ // if we checked the macStyle flags, then just check the family and ignore the subfamily
+ if (stbtt__matchpair(fc, nm, name, nlen, 16, -1)) return 1;
+ if (stbtt__matchpair(fc, nm, name, nlen, 1, -1)) return 1;
+ if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1;
+ } else {
+ if (stbtt__matchpair(fc, nm, name, nlen, 16, 17)) return 1;
+ if (stbtt__matchpair(fc, nm, name, nlen, 1, 2)) return 1;
+ if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1;
+ }
+
+ return 0;
+}
+
+int stbtt_FindMatchingFont(const unsigned char *font_collection, const char *name_utf8, stbtt_int32 flags)
+{
+ stbtt_int32 i;
+ for (i=0;;++i) {
+ stbtt_int32 off = stbtt_GetFontOffsetForIndex(font_collection, i);
+ if (off < 0) return off;
+ if (stbtt__matches((stbtt_uint8 *) font_collection, off, (stbtt_uint8*) name_utf8, flags))
+ return off;
+ }
+}
+
+#endif // STB_TRUETYPE_IMPLEMENTATION
diff --git a/libs/dgl/src/pugl/pugl.h b/libs/dgl/src/pugl/pugl.h index 2a6a59f..360f8e8 100644 --- a/libs/dgl/src/pugl/pugl.h +++ b/libs/dgl/src/pugl/pugl.h @@ -1,5 +1,5 @@ /* - Copyright 2012 David Robillard <http://drobilla.net> + Copyright 2012-2014 David Robillard <http://drobilla.net> Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above @@ -217,21 +217,54 @@ typedef void (*PuglScrollFunc)(PuglView* view, typedef void (*PuglSpecialFunc)(PuglView* view, bool press, PuglKey key); /** - Create a new GL window. - @param parent Parent window, or 0 for top level. - @param title Window title, or NULL. - @param width Window width in pixels. - @param height Window height in pixels. - @param resizable Whether window should be user resizable. - @param visible Whether window should be initially visible. + Create a Pugl context. + + To create a window, call the various puglInit* functions as necessary, then + call puglCreateWindow(). + + @param pargc Pointer to argument count (unused, for GLUT compatibility). + @param argv Arguments (unused, for GLUT compatibility). */ PUGL_API PuglView* -puglCreate(PuglNativeWindow parent, - const char* title, - int width, - int height, - bool resizable, - bool visible); +puglInit(int* pargc, char** argv); + +/** + Set the parent window before creating a window (for embedding). +*/ +PUGL_API void +puglInitWindowParent(PuglView* view, PuglNativeWindow parent); + +/** + Set the window size before creating a window. +*/ +PUGL_API void +puglInitWindowSize(PuglView* view, int width, int height); + +/** + Enable or disable resizing before creating a window. +*/ +PUGL_API void +puglInitResizable(PuglView* view, bool resizable); + +/** + Create a window with the settings given by the various puglInit functions. + + @return 1 (pugl does not currently support multiple windows). +*/ +PUGL_API int +puglCreateWindow(PuglView* view, const char* title); + +/** + Show the current window. +*/ +PUGL_API void +puglShowWindow(PuglView* view); + +/** + Hide the current window. +*/ +PUGL_API void +puglHideWindow(PuglView* view); /** Set the handle to be passed to all callbacks. diff --git a/libs/dgl/src/pugl/pugl_internal.h b/libs/dgl/src/pugl/pugl_internal.h index e824161..1f75830 100644 --- a/libs/dgl/src/pugl/pugl_internal.h +++ b/libs/dgl/src/pugl/pugl_internal.h @@ -39,14 +39,9 @@ # define PUGL_LOGF(fmt, ...) #endif -void puglDefaultReshape(PuglView* view, int width, int height); - typedef struct PuglInternalsImpl PuglInternals; struct PuglViewImpl { - int width; - int height; - PuglHandle handle; PuglCloseFunc closeFunc; PuglDisplayFunc displayFunc; @@ -59,13 +54,64 @@ struct PuglViewImpl { PuglInternals* impl; + PuglNativeWindow parent; + + int width; + int height; int mods; bool mouse_in_view; bool ignoreKeyRepeat; bool redisplay; + bool resizable; uint32_t event_timestamp_ms; }; +PuglInternals* puglInitInternals(); + +void puglDefaultReshape(PuglView* view, int width, int height); + +PuglView* +puglInit(int* pargc, char** argv) +{ + PuglView* view = (PuglView*)calloc(1, sizeof(PuglView)); + if (!view) { + return NULL; + } + + PuglInternals* impl = puglInitInternals(); + if (!impl) { + return NULL; + } + + view->impl = impl; + view->width = 640; + view->height = 480; + + return view; + + // unused + (void)pargc; (void)argv; +} + +void +puglInitWindowSize(PuglView* view, int width, int height) +{ + view->width = width; + view->height = height; +} + +void +puglInitWindowParent(PuglView* view, PuglNativeWindow parent) +{ + view->parent = parent; +} + +void +puglInitResizable(PuglView* view, bool resizable) +{ + view->resizable = resizable; +} + void puglSetHandle(PuglView* view, PuglHandle handle) { diff --git a/libs/dgl/src/pugl/pugl_osx.m b/libs/dgl/src/pugl/pugl_osx.m index 0770b11..72bbc8a 100644 --- a/libs/dgl/src/pugl/pugl_osx.m +++ b/libs/dgl/src/pugl/pugl_osx.m @@ -351,64 +351,97 @@ struct PuglInternalsImpl { id window; }; -PuglView* -puglCreate(PuglNativeWindow parent, - const char* title, - int width, - int height, - bool resizable, - bool visible) -{ - PuglView* view = (PuglView*)calloc(1, sizeof(PuglView)); - PuglInternals* impl = (PuglInternals*)calloc(1, sizeof(PuglInternals)); - if (!view || !impl) { - return NULL; - } +PuglInternals* +puglInitInternals() +{ + return (PuglInternals*)calloc(1, sizeof(PuglInternals)); +} - view->impl = impl; - view->width = width; - view->height = height; +int +puglCreateWindow(PuglView* view, const char* title) +{ + PuglInternals* impl = view->impl; [NSAutoreleasePool new]; [NSApplication sharedApplication]; - NSString* titleString = [[NSString alloc] - initWithBytes:title - length:strlen(title) - encoding:NSUTF8StringEncoding]; + impl->glview = [PuglOpenGLView new]; + impl->glview->puglview = view; + + if (view->resizable) { + [impl->glview setAutoresizingMask:NSViewWidthSizable|NSViewHeightSizable]; + } + + if (view->parent) { + NSView* pview = (NSView*)view->parent; + [pview addSubview:impl->glview]; + return 0; + } id window = [[PuglWindow new]retain]; - [window setPuglview:view]; - [window setTitle:titleString]; + if (title) { + NSString* titleString = [[NSString alloc] + initWithBytes:title + length:strlen(title) + encoding:NSUTF8StringEncoding]; - impl->glview = [PuglOpenGLView new]; - impl->window = window; - impl->glview->puglview = view; + [window setTitle:titleString]; + } + [window setPuglview:view]; [window setContentView:impl->glview]; - [NSApp activateIgnoringOtherApps:YES]; [window makeFirstResponder:impl->glview]; - [window makeKeyAndOrderFront:window]; - if (! visible) { - [window setIsVisible:NO]; + // wait for first puglShowWindow + [window setIsVisible:NO]; + + [NSApp activateIgnoringOtherApps:YES]; + [window center]; + + impl->window = window; + + return 0; +} + +void +puglShowWindow(PuglView* view) +{ + PuglInternals* impl = view->impl; + + if (impl->window) { + [impl->window setIsVisible:YES]; + } else { + [view->impl->glview setHidden:NO]; } +} - return view; +void +puglHideWindow(PuglView* view) +{ + PuglInternals* impl = view->impl; - // unused - (void)parent; (void)resizable; + if (impl->window) { + [impl->window setIsVisible:NO]; + } else { + [impl->glview setHidden:YES]; + } } void puglDestroy(PuglView* view) { view->impl->glview->puglview = NULL; - [view->impl->window close]; - [view->impl->glview release]; - [view->impl->window release]; + + if (view->impl->window) { + [view->impl->window close]; + [view->impl->glview release]; + [view->impl->window release]; + } else { + [view->impl->glview release]; + } + free(view->impl); free(view); } diff --git a/libs/dgl/src/pugl/pugl_win.cpp b/libs/dgl/src/pugl/pugl_win.cpp index 8ef0566..9837671 100644 --- a/libs/dgl/src/pugl/pugl_win.cpp +++ b/libs/dgl/src/pugl/pugl_win.cpp @@ -37,7 +37,9 @@ # define WHEEL_DELTA 120 #endif -const int LOCAL_CLOSE_MSG = WM_USER + 50; +#define PUGL_LOCAL_CLOSE_MSG (WM_USER + 50) + +HINSTANCE hInstance = NULL; struct PuglInternalsImpl { HWND hwnd; @@ -49,23 +51,29 @@ struct PuglInternalsImpl { LRESULT CALLBACK wndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam); -PuglView* -puglCreate(PuglNativeWindow parent, - const char* title, - int width, - int height, - bool resizable, - bool visible) +extern "C" { +BOOL WINAPI +DllMain(HINSTANCE hInst, DWORD, LPVOID) { - PuglView* view = (PuglView*)calloc(1, sizeof(PuglView)); - PuglInternals* impl = (PuglInternals*)calloc(1, sizeof(PuglInternals)); - if (!view || !impl) { - return NULL; - } + hInstance = hInst; + return 1; +} +} // extern "C" - view->impl = impl; - view->width = width; - view->height = height; +PuglInternals* +puglInitInternals() +{ + return (PuglInternals*)calloc(1, sizeof(PuglInternals)); +} + +int +puglCreateWindow(PuglView* view, const char* title) +{ + PuglInternals* impl = view->impl; + + if (!title) { + title = "Window"; + } // FIXME: This is nasty, and pugl should not have static anything. // Should class be a parameter? Does this make sense on other platforms? @@ -77,34 +85,34 @@ puglCreate(PuglNativeWindow parent, impl->wc.lpfnWndProc = wndProc; impl->wc.cbClsExtra = 0; impl->wc.cbWndExtra = 0; - impl->wc.hInstance = 0; - impl->wc.hIcon = LoadIcon(NULL, IDI_APPLICATION); - impl->wc.hCursor = LoadCursor(NULL, IDC_ARROW); + impl->wc.hInstance = hInstance; + impl->wc.hIcon = LoadIcon(hInstance, IDI_APPLICATION); + impl->wc.hCursor = LoadCursor(hInstance, IDC_ARROW); impl->wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH); impl->wc.lpszMenuName = NULL; impl->wc.lpszClassName = classNameBuf; RegisterClass(&impl->wc); int winFlags = WS_POPUPWINDOW | WS_CAPTION; - if (resizable) { + if (view->resizable) { winFlags |= WS_SIZEBOX; } // Adjust the overall window size to accomodate our requested client size - RECT wr = { 0, 0, width, height }; + RECT wr = { 0, 0, view->width, view->height }; AdjustWindowRectEx(&wr, winFlags, FALSE, WS_EX_TOPMOST); impl->hwnd = CreateWindowEx( WS_EX_TOPMOST, classNameBuf, title, - (visible ? WS_VISIBLE : 0) | (parent ? WS_CHILD : winFlags), - 0, 0, wr.right-wr.left, wr.bottom-wr.top, - (HWND)parent, NULL, NULL, NULL); + view->parent ? WS_CHILD : winFlags, + CW_USEDEFAULT, CW_USEDEFAULT, wr.right-wr.left, wr.bottom-wr.top, + (HWND)view->parent, NULL, hInstance, NULL); if (!impl->hwnd) { free(impl); free(view); - return NULL; + return 1; } #ifdef _WIN64 @@ -131,10 +139,23 @@ puglCreate(PuglNativeWindow parent, impl->hglrc = wglCreateContext(impl->hdc); wglMakeCurrent(impl->hdc, impl->hglrc); - view->width = width; - view->height = height; + return 0; +} + +void +puglShowWindow(PuglView* view) +{ + PuglInternals* impl = view->impl; + + ShowWindow(impl->hwnd, SW_SHOWNORMAL); +} + +void +puglHideWindow(PuglView* view) +{ + PuglInternals* impl = view->impl; - return view; + ShowWindow(impl->hwnd, SW_HIDE); } void @@ -149,7 +170,7 @@ puglDestroy(PuglView* view) free(view); } -void +static void puglReshape(PuglView* view, int width, int height) { wglMakeCurrent(view->impl->hdc, view->impl->hglrc); @@ -164,7 +185,7 @@ puglReshape(PuglView* view, int width, int height) view->height = height; } -void +static void puglDisplay(PuglView* view) { wglMakeCurrent(view->impl->hdc, view->impl->hglrc); @@ -221,7 +242,7 @@ processMouseEvent(PuglView* view, int button, bool press, LPARAM lParam) } else { ReleaseCapture(); } - + if (view->mouseFunc) { view->mouseFunc(view, button, press, GET_X_LPARAM(lParam), @@ -251,7 +272,7 @@ handleMessage(PuglView* view, UINT message, WPARAM wParam, LPARAM lParam) case WM_CREATE: case WM_SHOWWINDOW: case WM_SIZE: - RECT rect; + RECT rect; GetClientRect(view->impl->hwnd, &rect); puglReshape(view, rect.right, rect.bottom); view->width = rect.right; @@ -316,7 +337,7 @@ handleMessage(PuglView* view, UINT message, WPARAM wParam, LPARAM lParam) } break; case WM_QUIT: - case LOCAL_CLOSE_MSG: + case PUGL_LOCAL_CLOSE_MSG: if (view->closeFunc) { view->closeFunc(view); } @@ -359,7 +380,7 @@ wndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) PostMessage(hwnd, WM_SHOWWINDOW, TRUE, 0); return 0; case WM_CLOSE: - PostMessage(hwnd, LOCAL_CLOSE_MSG, wParam, lParam); + PostMessage(hwnd, PUGL_LOCAL_CLOSE_MSG, wParam, lParam); return 0; case WM_DESTROY: return 0; diff --git a/libs/dgl/src/pugl/pugl_x11.c b/libs/dgl/src/pugl/pugl_x11.c index d38eecf..fdba1b6 100644 --- a/libs/dgl/src/pugl/pugl_x11.c +++ b/libs/dgl/src/pugl/pugl_x11.c @@ -65,23 +65,16 @@ static int attrListDbl[] = { None }; -PuglView* -puglCreate(PuglNativeWindow parent, - const char* title, - int width, - int height, - bool resizable, - bool visible) +PuglInternals* +puglInitInternals() { - PuglView* view = (PuglView*)calloc(1, sizeof(PuglView)); - PuglInternals* impl = (PuglInternals*)calloc(1, sizeof(PuglInternals)); - if (!view || !impl) { - return NULL; - } + return (PuglInternals*)calloc(1, sizeof(PuglInternals)); +} - view->impl = impl; - view->width = width; - view->height = height; +int +puglCreateWindow(PuglView* view, const char* title) +{ + PuglInternals* impl = view->impl; impl->display = XOpenDisplay(0); impl->screen = DefaultScreen(impl->display); @@ -102,8 +95,8 @@ puglCreate(PuglNativeWindow parent, impl->ctx = glXCreateContext(impl->display, vi, 0, GL_TRUE); - Window xParent = parent - ? (Window)parent + Window xParent = view->parent + ? (Window)view->parent : RootWindow(impl->display, impl->screen); Colormap cmap = XCreateColormap( @@ -116,24 +109,24 @@ puglCreate(PuglNativeWindow parent, attr.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask -#ifdef XKEYFOCUSGRAB +#ifdef PUGL_GRAB_FOCUS | EnterWindowMask #endif | PointerMotionMask | StructureNotifyMask; impl->win = XCreateWindow( impl->display, xParent, - 0, 0, (unsigned int)view->width, (unsigned int)view->height, 0, vi->depth, InputOutput, vi->visual, + 0, 0, view->width, view->height, 0, vi->depth, InputOutput, vi->visual, CWBorderPixel | CWColormap | CWEventMask, &attr); XSizeHints sizeHints; memset(&sizeHints, 0, sizeof(sizeHints)); - if (!resizable) { + if (!view->resizable) { sizeHints.flags = PMinSize|PMaxSize; - sizeHints.min_width = width; - sizeHints.min_height = height; - sizeHints.max_width = width; - sizeHints.max_height = height; + sizeHints.min_width = view->width; + sizeHints.min_height = view->height; + sizeHints.max_width = view->width; + sizeHints.max_height = view->height; XSetNormalHints(impl->display, impl->win, &sizeHints); } @@ -141,15 +134,11 @@ puglCreate(PuglNativeWindow parent, XStoreName(impl->display, impl->win, title); } - if (!parent) { + if (!view->parent) { Atom wmDelete = XInternAtom(impl->display, "WM_DELETE_WINDOW", True); XSetWMProtocols(impl->display, impl->win, &wmDelete, 1); } - if (visible) { - XMapRaised(impl->display, impl->win); - } - if (glXIsDirect(impl->display, impl->ctx)) { PUGL_LOG("DRI enabled (to disable, set LIBGL_ALWAYS_INDIRECT=1\n"); } else { @@ -158,7 +147,25 @@ puglCreate(PuglNativeWindow parent, XFree(vi); - return view; + glXMakeCurrent(view->impl->display, view->impl->win, view->impl->ctx); + + return 0; +} + +void +puglShowWindow(PuglView* view) +{ + PuglInternals* impl = view->impl; + + XMapRaised(impl->display, impl->win); +} + +void +puglHideWindow(PuglView* view) +{ + PuglInternals* impl = view->impl; + + XUnmapWindow(impl->display, impl->win); } void @@ -245,9 +252,9 @@ keySymToSpecial(KeySym sym) } static void -setModifiers(PuglView* view, unsigned xstate, unsigned long xtime) +setModifiers(PuglView* view, unsigned xstate, unsigned xtime) { - view->event_timestamp_ms = (uint32_t)xtime; + view->event_timestamp_ms = xtime; view->mods = 0; view->mods |= (xstate & ShiftMask) ? PUGL_MOD_SHIFT : 0; @@ -273,7 +280,7 @@ dispatchKey(PuglView* view, XEvent* event, bool press) if (special && view->specialFunc) { view->specialFunc(view, press, special); } else if (!special && view->keyboardFunc) { - view->keyboardFunc(view, press, (uint32_t)str[0]); + view->keyboardFunc(view, press, str[0]); } } @@ -330,7 +337,7 @@ puglProcessEvents(PuglView* view) if (view->mouseFunc && (event.xbutton.button < 4 || event.xbutton.button > 7)) { view->mouseFunc(view, - (int)event.xbutton.button, event.type == ButtonPress, + event.xbutton.button, event.type == ButtonPress, event.xbutton.x, event.xbutton.y); } break; @@ -353,16 +360,17 @@ puglProcessEvents(PuglView* view) } dispatchKey(view, &event, false); break; - case ClientMessage: - if (!strcmp(XGetAtomName(view->impl->display, - event.xclient.message_type), - "WM_PROTOCOLS")) { + case ClientMessage: { + char* type = XGetAtomName(view->impl->display, + event.xclient.message_type); + if (!strcmp(type, "WM_PROTOCOLS")) { if (view->closeFunc) { view->closeFunc(view); } } - break; -#ifdef XKEYFOCUSGRAB + XFree(type); + } break; +#ifdef PUGL_GRAB_FOCUS case EnterNotify: XSetInputFocus(view->impl->display, view->impl->win, @@ -391,5 +399,5 @@ puglPostRedisplay(PuglView* view) PuglNativeWindow puglGetNativeWindow(PuglView* view) { - return (PuglNativeWindow)view->impl->win; + return view->impl->win; } diff --git a/libs/distrho/DistrhoPlugin.hpp b/libs/distrho/DistrhoPlugin.hpp index f034d4d..a548314 100644 --- a/libs/distrho/DistrhoPlugin.hpp +++ b/libs/distrho/DistrhoPlugin.hpp @@ -285,9 +285,9 @@ protected: virtual void d_activate() {} virtual void d_deactivate() {} #if DISTRHO_PLUGIN_IS_SYNTH - virtual void d_run(float** inputs, float** outputs, uint32_t frames, const MidiEvent* midiEvents, uint32_t midiEventCount) = 0; + virtual void d_run(const float** inputs, float** outputs, uint32_t frames, const MidiEvent* midiEvents, uint32_t midiEventCount) = 0; #else - virtual void d_run(float** inputs, float** outputs, uint32_t frames) = 0; + virtual void d_run(const float** inputs, float** outputs, uint32_t frames) = 0; #endif // ------------------------------------------------------------------- diff --git a/libs/distrho/DistrhoPluginMain.cpp b/libs/distrho/DistrhoPluginMain.cpp index 0671344..8fce7db 100644 --- a/libs/distrho/DistrhoPluginMain.cpp +++ b/libs/distrho/DistrhoPluginMain.cpp @@ -18,6 +18,8 @@ #if defined(DISTRHO_PLUGIN_TARGET_CARLA) # include "src/DistrhoPluginCarla.cpp" +#elif defined(DISTRHO_PLUGIN_TARGET_JACK) +# include "src/DistrhoPluginJack.cpp" #elif (defined(DISTRHO_PLUGIN_TARGET_LADSPA) || defined(DISTRHO_PLUGIN_TARGET_DSSI)) # include "src/DistrhoPluginLADSPA+DSSI.cpp" #elif defined(DISTRHO_PLUGIN_TARGET_LV2) diff --git a/libs/distrho/DistrhoUI.hpp b/libs/distrho/DistrhoUI.hpp index 00625ae..98af2a0 100644 --- a/libs/distrho/DistrhoUI.hpp +++ b/libs/distrho/DistrhoUI.hpp @@ -22,12 +22,19 @@ #include "../dgl/Widget.hpp" +#if DISTRHO_UI_USE_NANOVG +# include "../dgl/NanoVG.hpp" +typedef DGL::NanoWidget UIWidget; +#else +typedef DGL::Widget UIWidget; +#endif + START_NAMESPACE_DISTRHO // ----------------------------------------------------------------------- // UI -class UI : public DGL::Widget +class UI : public UIWidget { public: UI(); @@ -49,7 +56,14 @@ public: // ------------------------------------------------------------------- // Host UI State - void d_uiResize(uint width, uint height); + void d_setSize(uint width, uint height); + +#if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS + // ------------------------------------------------------------------- + // Direct DSP access - DO NOT USE THIS UNLESS STRICTLY NECESSARY!! + + void* d_getPluginInstancePointer() const noexcept; +#endif protected: // ------------------------------------------------------------------- @@ -74,13 +88,7 @@ protected: // UI Callbacks (optional) virtual void d_uiIdle() {} - -#if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS - // ------------------------------------------------------------------- - // Direct DSP access - DO NOT USE THIS UNLESS STRICTLY NECESSARY!! - - void* d_getPluginInstancePointer() const noexcept; -#endif + virtual void d_uiReshape(int width, int height); // ------------------------------------------------------------------- @@ -88,6 +96,14 @@ private: struct PrivateData; PrivateData* const pData; friend class UIExporter; + friend class UIExporterWindow; + + // these should not be used + void setAbsoluteX(int) const noexcept {} + void setAbsoluteY(int) const noexcept {} + void setAbsolutePos(int, int) const noexcept {} + void setAbsolutePos(const DGL::Point<int>&) const noexcept {} + void setNeedsFullViewport(bool) const noexcept {} DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(UI) }; diff --git a/libs/distrho/DistrhoUIMain.cpp b/libs/distrho/DistrhoUIMain.cpp index 27f219a..cb1cb6e 100644 --- a/libs/distrho/DistrhoUIMain.cpp +++ b/libs/distrho/DistrhoUIMain.cpp @@ -18,6 +18,8 @@ #if defined(DISTRHO_PLUGIN_TARGET_CARLA) // nothing +#elif defined(DISTRHO_PLUGIN_TARGET_JACK) +// nothing #elif defined(DISTRHO_PLUGIN_TARGET_DSSI) # include "src/DistrhoUIDSSI.cpp" #elif defined(DISTRHO_PLUGIN_TARGET_LV2) diff --git a/libs/distrho/DistrhoUtils.hpp b/libs/distrho/DistrhoUtils.hpp index 82fa8df..76669d2 100644 --- a/libs/distrho/DistrhoUtils.hpp +++ b/libs/distrho/DistrhoUtils.hpp @@ -30,13 +30,6 @@ # include <stdint.h> #endif -#ifdef DISTRHO_OS_WINDOWS -# include <winsock2.h> -# include <windows.h> -#else -# include <unistd.h> -#endif - #if defined(DISTRHO_OS_MAC) && ! defined(CARLA_OS_MAC) namespace std { inline float @@ -136,36 +129,5 @@ void d_safe_exception(const char* const exception, const char* const file, const } // ----------------------------------------------------------------------- -// d_*sleep - -static inline -void d_sleep(const uint secs) -{ - DISTRHO_SAFE_ASSERT_RETURN(secs > 0,); - - try { -#ifdef DISTRHO_OS_WINDOWS - ::Sleep(secs * 1000); -#else - ::sleep(secs); -#endif - } DISTRHO_SAFE_EXCEPTION("carla_sleep"); -} - -static inline -void d_msleep(const uint msecs) -{ - DISTRHO_SAFE_ASSERT_RETURN(msecs > 0,); - - try { -#ifdef DISTRHO_OS_WINDOWS - ::Sleep(msecs); -#else - ::usleep(msecs * 1000); -#endif - } DISTRHO_SAFE_EXCEPTION("carla_msleep"); -} - -// ----------------------------------------------------------------------- #endif // DISTRHO_UTILS_HPP_INCLUDED diff --git a/libs/distrho/extra/d_leakdetector.hpp b/libs/distrho/extra/d_leakdetector.hpp index ca5a1b7..ede4db9 100644 --- a/libs/distrho/extra/d_leakdetector.hpp +++ b/libs/distrho/extra/d_leakdetector.hpp @@ -66,12 +66,12 @@ To use it, use the DISTRHO_LEAK_DETECTOR macro as a simple way to put one in your class declaration. */ -template <class OwnerClass> +template<class OwnerClass> class DistrhoLeakedObjectDetector { public: //============================================================================== - DistrhoLeakedObjectDetector() noexcept { ++(getCounter().numObjects); } + DistrhoLeakedObjectDetector() noexcept { ++(getCounter().numObjects); } DistrhoLeakedObjectDetector(const DistrhoLeakedObjectDetector&) noexcept { ++(getCounter().numObjects); } ~DistrhoLeakedObjectDetector() noexcept diff --git a/libs/distrho/extra/d_mutex.hpp b/libs/distrho/extra/d_mutex.hpp new file mode 100644 index 0000000..8bbcb11 --- /dev/null +++ b/libs/distrho/extra/d_mutex.hpp @@ -0,0 +1,226 @@ +/* + * DISTRHO Plugin Framework (DPF) + * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com> + * + * Permission to use, copy, modify, and/or distribute this software for any purpose with + * or without fee is hereby granted, provided that the above copyright notice and this + * permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD + * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN + * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER + * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef DISTRHO_MUTEX_HPP_INCLUDED +#define DISTRHO_MUTEX_HPP_INCLUDED + +#include "../DistrhoUtils.hpp" + +#ifdef DISTRHO_OS_WINDOWS +# include <winsock2.h> +# include <windows.h> +#endif + +#include <pthread.h> + +// ----------------------------------------------------------------------- +// Mutex class + +class Mutex +{ +public: + /* + * Constructor. + */ + Mutex() noexcept + { + pthread_mutex_init(&fMutex, nullptr); + } + + /* + * Destructor. + */ + ~Mutex() noexcept + { + pthread_mutex_destroy(&fMutex); + } + + /* + * Lock the mutex. + */ + void lock() const noexcept + { + pthread_mutex_lock(&fMutex); + } + + /* + * Try to lock the mutex. + * Returns true if successful. + */ + bool tryLock() const noexcept + { + return (pthread_mutex_trylock(&fMutex) == 0); + } + + /* + * Unlock the mutex. + */ + void unlock() const noexcept + { + pthread_mutex_unlock(&fMutex); + } + +private: + mutable pthread_mutex_t fMutex; + + DISTRHO_PREVENT_HEAP_ALLOCATION + DISTRHO_DECLARE_NON_COPY_CLASS(Mutex) +}; + +// ----------------------------------------------------------------------- +// RecursiveMutex class + +class RecursiveMutex +{ +public: + /* + * Constructor. + */ + RecursiveMutex() noexcept + { +#ifdef DISTRHO_OS_WINDOWS + InitializeCriticalSection(&fSection); +#else + pthread_mutexattr_t atts; + pthread_mutexattr_init(&atts); + pthread_mutexattr_settype(&atts, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&fMutex, &atts); + pthread_mutexattr_destroy(&atts); +#endif + } + + /* + * Destructor. + */ + ~RecursiveMutex() noexcept + { +#ifdef DISTRHO_OS_WINDOWS + DeleteCriticalSection(&fSection); +#else + pthread_mutex_destroy(&fMutex); +#endif + } + + /* + * Lock the mutex. + */ + void lock() const noexcept + { +#ifdef DISTRHO_OS_WINDOWS + EnterCriticalSection(&fSection); +#else + pthread_mutex_lock(&fMutex); +#endif + } + + /* + * Try to lock the mutex. + * Returns true if successful. + */ + bool tryLock() const noexcept + { +#ifdef DISTRHO_OS_WINDOWS + return (TryEnterCriticalSection(&fSection) != FALSE); +#else + return (pthread_mutex_trylock(&fMutex) == 0); +#endif + } + + /* + * Unlock the mutex. + */ + void unlock() const noexcept + { +#ifdef DISTRHO_OS_WINDOWS + LeaveCriticalSection(&fSection); +#else + pthread_mutex_unlock(&fMutex); +#endif + } + +private: +#ifdef DISTRHO_OS_WINDOWS + mutable CRITICAL_SECTION fSection; +#else + mutable pthread_mutex_t fMutex; +#endif + + DISTRHO_PREVENT_HEAP_ALLOCATION + DISTRHO_DECLARE_NON_COPY_CLASS(RecursiveMutex) +}; + +// ----------------------------------------------------------------------- +// Helper class to lock&unlock a mutex during a function scope. + +template <class Mutex> +class ScopedLocker +{ +public: + ScopedLocker(const Mutex& mutex) noexcept + : fMutex(mutex) + { + fMutex.lock(); + } + + ~ScopedLocker() noexcept + { + fMutex.unlock(); + } + +private: + const Mutex& fMutex; + + DISTRHO_PREVENT_HEAP_ALLOCATION + DISTRHO_DECLARE_NON_COPY_CLASS(ScopedLocker) +}; + +// ----------------------------------------------------------------------- +// Helper class to unlock&lock a mutex during a function scope. + +template <class Mutex> +class ScopedUnlocker +{ +public: + ScopedUnlocker(const Mutex& mutex) noexcept + : fMutex(mutex) + { + fMutex.unlock(); + } + + ~ScopedUnlocker() noexcept + { + fMutex.lock(); + } + +private: + const Mutex& fMutex; + + DISTRHO_PREVENT_HEAP_ALLOCATION + DISTRHO_DECLARE_NON_COPY_CLASS(ScopedUnlocker) +}; + +// ----------------------------------------------------------------------- +// Define types + +typedef ScopedLocker<Mutex> MutexLocker; +typedef ScopedLocker<RecursiveMutex> RecursiveMutexLocker; + +typedef ScopedUnlocker<Mutex> MutexUnlocker; +typedef ScopedUnlocker<RecursiveMutex> RecursiveMutexUnlocker; + +// ----------------------------------------------------------------------- + +#endif // DISTRHO_MUTEX_HPP_INCLUDED diff --git a/libs/distrho/extra/d_scopedpointer.hpp b/libs/distrho/extra/d_scopedpointer.hpp new file mode 100644 index 0000000..d7cc4eb --- /dev/null +++ b/libs/distrho/extra/d_scopedpointer.hpp @@ -0,0 +1,243 @@ +/* + * DISTRHO Plugin Framework (DPF) + * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com> + * + * Permission to use, copy, modify, and/or distribute this software for any purpose with + * or without fee is hereby granted, provided that the above copyright notice and this + * permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD + * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN + * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER + * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef DISTRHO_SCOPED_POINTER_HPP_INCLUDED +#define DISTRHO_SCOPED_POINTER_HPP_INCLUDED + +#include "../DistrhoUtils.hpp" + +#include <algorithm> + +// ----------------------------------------------------------------------- +// The following code was based from juce-core ScopedPointer class +// Copyright (C) 2013 Raw Material Software Ltd. + +/** + Used by container classes as an indirect way to delete an object of a + particular type. + + The generic implementation of this class simply calls 'delete', but you can + create a specialised version of it for a particular class if you need to + delete that type of object in a more appropriate way. +*/ +template<typename ObjectType> +struct ContainerDeletePolicy +{ + static void destroy(ObjectType* const object) + { + delete object; + } +}; + +//============================================================================== +/** + This class holds a pointer which is automatically deleted when this object goes + out of scope. + + Once a pointer has been passed to a ScopedPointer, it will make sure that the pointer + gets deleted when the ScopedPointer is deleted. Using the ScopedPointer on the stack or + as member variables is a good way to use RAII to avoid accidentally leaking dynamically + created objects. + + A ScopedPointer can be used in pretty much the same way that you'd use a normal pointer + to an object. If you use the assignment operator to assign a different object to a + ScopedPointer, the old one will be automatically deleted. + + A const ScopedPointer is guaranteed not to lose ownership of its object or change the + object to which it points during its lifetime. This means that making a copy of a const + ScopedPointer is impossible, as that would involve the new copy taking ownership from the + old one. + + If you need to get a pointer out of a ScopedPointer without it being deleted, you + can use the release() method. + + Something to note is the main difference between this class and the std::auto_ptr class, + which is that ScopedPointer provides a cast-to-object operator, wheras std::auto_ptr + requires that you always call get() to retrieve the pointer. The advantages of providing + the cast is that you don't need to call get(), so can use the ScopedPointer in pretty much + exactly the same way as a raw pointer. The disadvantage is that the compiler is free to + use the cast in unexpected and sometimes dangerous ways - in particular, it becomes difficult + to return a ScopedPointer as the result of a function. To avoid this causing errors, + ScopedPointer contains an overloaded constructor that should cause a syntax error in these + circumstances, but it does mean that instead of returning a ScopedPointer from a function, + you'd need to return a raw pointer (or use a std::auto_ptr instead). +*/ +template<class ObjectType> +class ScopedPointer +{ +public: + //============================================================================== + /** Creates a ScopedPointer containing a null pointer. */ + ScopedPointer() noexcept + : object(nullptr) {} + + /** Creates a ScopedPointer that owns the specified object. */ + ScopedPointer(ObjectType* const objectToTakePossessionOf) noexcept + : object(objectToTakePossessionOf) {} + + /** Creates a ScopedPointer that takes its pointer from another ScopedPointer. + + Because a pointer can only belong to one ScopedPointer, this transfers + the pointer from the other object to this one, and the other object is reset to + be a null pointer. + */ + ScopedPointer(ScopedPointer& objectToTransferFrom) noexcept + : object(objectToTransferFrom.object) + { + objectToTransferFrom.object = nullptr; + } + + /** Destructor. + This will delete the object that this ScopedPointer currently refers to. + */ + ~ScopedPointer() + { + ContainerDeletePolicy<ObjectType>::destroy(object); + } + + /** Changes this ScopedPointer to point to a new object. + + Because a pointer can only belong to one ScopedPointer, this transfers + the pointer from the other object to this one, and the other object is reset to + be a null pointer. + + If this ScopedPointer already points to an object, that object + will first be deleted. + */ + ScopedPointer& operator=(ScopedPointer& objectToTransferFrom) + { + if (this != objectToTransferFrom.getAddress()) + { + // Two ScopedPointers should never be able to refer to the same object - if + // this happens, you must have done something dodgy! + DISTRHO_SAFE_ASSERT_RETURN(object == nullptr || object != objectToTransferFrom.object, *this); + + ObjectType* const oldObject = object; + object = objectToTransferFrom.object; + objectToTransferFrom.object = nullptr; + ContainerDeletePolicy<ObjectType>::destroy(oldObject); + } + + return *this; + } + + /** Changes this ScopedPointer to point to a new object. + + If this ScopedPointer already points to an object, that object + will first be deleted. + + The pointer that you pass in may be a nullptr. + */ + ScopedPointer& operator=(ObjectType* const newObjectToTakePossessionOf) + { + if (object != newObjectToTakePossessionOf) + { + ObjectType* const oldObject = object; + object = newObjectToTakePossessionOf; + ContainerDeletePolicy<ObjectType>::destroy(oldObject); + } + + return *this; + } + + //============================================================================== + /** Returns the object that this ScopedPointer refers to. */ + operator ObjectType*() const noexcept { return object; } + + /** Returns the object that this ScopedPointer refers to. */ + ObjectType* get() const noexcept { return object; } + + /** Returns the object that this ScopedPointer refers to. */ + ObjectType& operator*() const noexcept { return *object; } + + /** Lets you access methods and properties of the object that this ScopedPointer refers to. */ + ObjectType* operator->() const noexcept { return object; } + + //============================================================================== + /** Removes the current object from this ScopedPointer without deleting it. + This will return the current object, and set the ScopedPointer to a null pointer. + */ + ObjectType* release() noexcept { ObjectType* const o = object; object = nullptr; return o; } + + //============================================================================== + /** Swaps this object with that of another ScopedPointer. + The two objects simply exchange their pointers. + */ + void swapWith(ScopedPointer<ObjectType>& other) noexcept + { + // Two ScopedPointers should never be able to refer to the same object - if + // this happens, you must have done something dodgy! + DISTRHO_SAFE_ASSERT_RETURN(object != other.object && this != other.getAddress(),); + + std::swap(object, other.object); + } + +private: + //============================================================================== + ObjectType* object; + + // (Required as an alternative to the overloaded & operator). + const ScopedPointer* getAddress() const noexcept { return this; } + +#ifndef _MSC_VER // (MSVC can't deal with multiple copy constructors) + /* The copy constructors are private to stop people accidentally copying a const ScopedPointer + (the compiler would let you do so by implicitly casting the source to its raw object pointer). + + A side effect of this is that in a compiler that doesn't support C++11, you may hit an + error when you write something like this: + + ScopedPointer<MyClass> m = new MyClass(); // Compile error: copy constructor is private. + + Even though the compiler would normally ignore the assignment here, it can't do so when the + copy constructor is private. It's very easy to fix though - just write it like this: + + ScopedPointer<MyClass> m (new MyClass()); // Compiles OK + + It's probably best to use the latter form when writing your object declarations anyway, as + this is a better representation of the code that you actually want the compiler to produce. + */ +# ifdef DISTRHO_PROPER_CPP11_SUPPORT + ScopedPointer(const ScopedPointer&) = delete; + ScopedPointer& operator=(const ScopedPointer&) = delete; +# else + ScopedPointer(const ScopedPointer&); + ScopedPointer& operator=(const ScopedPointer&); +# endif +#endif +}; + +//============================================================================== +/** Compares a ScopedPointer with another pointer. + This can be handy for checking whether this is a null pointer. +*/ +template<class ObjectType> +bool operator==(const ScopedPointer<ObjectType>& pointer1, ObjectType* const pointer2) noexcept +{ + return static_cast<ObjectType*>(pointer1) == pointer2; +} + +/** Compares a ScopedPointer with another pointer. + This can be handy for checking whether this is a null pointer. +*/ +template<class ObjectType> +bool operator!=(const ScopedPointer<ObjectType>& pointer1, ObjectType* const pointer2) noexcept +{ + return static_cast<ObjectType*>(pointer1) != pointer2; +} + +// ----------------------------------------------------------------------- + +#endif // DISTRHO_SCOPED_POINTER_HPP_INCLUDED diff --git a/libs/distrho/extra/d_sleep.hpp b/libs/distrho/extra/d_sleep.hpp new file mode 100644 index 0000000..c9c2c59 --- /dev/null +++ b/libs/distrho/extra/d_sleep.hpp @@ -0,0 +1,62 @@ +/* + * DISTRHO Plugin Framework (DPF) + * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com> + * + * Permission to use, copy, modify, and/or distribute this software for any purpose with + * or without fee is hereby granted, provided that the above copyright notice and this + * permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD + * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN + * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER + * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef DISTRHO_SLEEP_HPP_INCLUDED +#define DISTRHO_SLEEP_HPP_INCLUDED + +#include "../DistrhoUtils.hpp" + +#ifdef DISTRHO_OS_WINDOWS +# include <winsock2.h> +# include <windows.h> +#else +# include <unistd.h> +#endif + +// ----------------------------------------------------------------------- +// d_*sleep + +static inline +void d_sleep(const uint secs) noexcept +{ + DISTRHO_SAFE_ASSERT_RETURN(secs > 0,); + + try { +#ifdef DISTRHO_OS_WINDOWS + ::Sleep(secs * 1000); +#else + ::sleep(secs); +#endif + } DISTRHO_SAFE_EXCEPTION("d_sleep"); +} + +static inline +void d_msleep(const uint msecs) noexcept +{ + DISTRHO_SAFE_ASSERT_RETURN(msecs > 0,); + + try { +#ifdef DISTRHO_OS_WINDOWS + ::Sleep(msecs); +#else + ::usleep(msecs * 1000); +#endif + } DISTRHO_SAFE_EXCEPTION("d_msleep"); +} + +// ----------------------------------------------------------------------- + +#endif // DISTRHO_SLEEP_HPP_INCLUDED diff --git a/libs/distrho/src/DistrhoDefines.h b/libs/distrho/src/DistrhoDefines.h index ce0e10a..461dbc3 100644 --- a/libs/distrho/src/DistrhoDefines.h +++ b/libs/distrho/src/DistrhoDefines.h @@ -37,10 +37,8 @@ # define DISTRHO_DLL_EXTENSION "dylib" # elif defined(__HAIKU__) # define DISTRHO_OS_HAIKU 1 -# define DISTRHO_DLL_EXTENSION "so" # elif defined(__linux__) # define DISTRHO_OS_LINUX 1 -# define DISTRHO_DLL_EXTENSION "so" # endif #endif @@ -53,7 +51,7 @@ # define PROPER_CPP11_SUPPORT #elif __cplusplus >= 201103L || (defined(__GNUC__) && defined(__GXX_EXPERIMENTAL_CXX0X__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 405) || __has_extension(cxx_noexcept) # define PROPER_CPP11_SUPPORT -# if (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 407) || ! __has_extension(cxx_override_control) +# if (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 407) && ! __has_extension(cxx_override_control) # define override // gcc4.7+ only # define final // gcc4.7+ only # endif @@ -67,10 +65,10 @@ #endif /* Define DISTRHO_SAFE_ASSERT* */ -#define DISTRHO_SAFE_ASSERT(cond) if (cond) d_pass(); else d_safe_assert(#cond, __FILE__, __LINE__); -#define DISTRHO_SAFE_ASSERT_BREAK(cond) if (cond) d_pass(); else { d_safe_assert(#cond, __FILE__, __LINE__); break; } -#define DISTRHO_SAFE_ASSERT_CONTINUE(cond) if (cond) d_pass(); else { d_safe_assert(#cond, __FILE__, __LINE__); continue; } -#define DISTRHO_SAFE_ASSERT_RETURN(cond, ret) if (cond) d_pass(); else { d_safe_assert(#cond, __FILE__, __LINE__); return ret; } +#define DISTRHO_SAFE_ASSERT(cond) if (! (cond)) d_safe_assert(#cond, __FILE__, __LINE__); +#define DISTRHO_SAFE_ASSERT_BREAK(cond) if (! (cond)) { d_safe_assert(#cond, __FILE__, __LINE__); break; } +#define DISTRHO_SAFE_ASSERT_CONTINUE(cond) if (! (cond)) { d_safe_assert(#cond, __FILE__, __LINE__); continue; } +#define DISTRHO_SAFE_ASSERT_RETURN(cond, ret) if (! (cond)) { d_safe_assert(#cond, __FILE__, __LINE__); return ret; } /* Define DISTRHO_SAFE_EXCEPTION */ #define DISTRHO_SAFE_EXCEPTION(msg) catch(...) { d_safe_exception(msg, __FILE__, __LINE__); } diff --git a/libs/distrho/src/DistrhoPlugin.cpp b/libs/distrho/src/DistrhoPlugin.cpp index 7e9f382..f1b079b 100644 --- a/libs/distrho/src/DistrhoPlugin.cpp +++ b/libs/distrho/src/DistrhoPlugin.cpp @@ -80,6 +80,9 @@ double Plugin::d_getSampleRate() const noexcept #if DISTRHO_PLUGIN_WANT_TIMEPOS const TimePos& Plugin::d_getTimePos() const noexcept { + // timePos outside run() may not be valid + DISTRHO_SAFE_ASSERT(pData->isProcessing); + return pData->timePos; } #endif diff --git a/libs/distrho/src/DistrhoPluginCarla.cpp b/libs/distrho/src/DistrhoPluginCarla.cpp index 982dbec..2e1b771 100644 --- a/libs/distrho/src/DistrhoPluginCarla.cpp +++ b/libs/distrho/src/DistrhoPluginCarla.cpp @@ -43,7 +43,7 @@ public: UICarla(const NativeHostDescriptor* const host, PluginExporter* const plugin) : fHost(host), fPlugin(plugin), - fUI(this, 0, editParameterCallback, setParameterCallback, setStateCallback, sendNoteCallback, uiResizeCallback, plugin->getInstancePointer()) + fUI(this, 0, editParameterCallback, setParameterCallback, setStateCallback, sendNoteCallback, setSizeCallback, plugin->getInstancePointer()) { fUI.setTitle(host->uiName); @@ -110,7 +110,7 @@ protected: // TODO } - void handleUiResize(const uint width, const uint height) + void handleSetSize(const uint width, const uint height) { fUI.setSize(width, height); } @@ -154,9 +154,9 @@ private: } #endif - static void uiResizeCallback(void* ptr, uint width, uint height) + static void setSizeCallback(void* ptr, uint width, uint height) { - handlePtr->handleUiResize(width, height); + handlePtr->handleSetSize(width, height); } #undef handlePtr @@ -332,12 +332,12 @@ protected: carla_copy<uint8_t>(realMidiEvent.buf, midiEvent.data, midiEvent.size); } - fPlugin.run(inBuffer, outBuffer, frames, realMidiEvents, midiEventCount); + fPlugin.run(const_cast<const float**>(inBuffer), outBuffer, frames, realMidiEvents, midiEventCount); } #else void process(float** const inBuffer, float** const outBuffer, const uint32_t frames, const NativeMidiEvent* const, const uint32_t) override { - fPlugin.run(inBuffer, outBuffer, frames); + fPlugin.run(const_cast<const float**>(inBuffer), outBuffer, frames); } #endif diff --git a/libs/distrho/src/DistrhoPluginChecks.h b/libs/distrho/src/DistrhoPluginChecks.h index 3ced261..3a06ee4 100644 --- a/libs/distrho/src/DistrhoPluginChecks.h +++ b/libs/distrho/src/DistrhoPluginChecks.h @@ -59,6 +59,14 @@ # define DISTRHO_PLUGIN_WANT_DIRECT_ACCESS 0 #endif +#ifndef DISTRHO_PLUGIN_IS_RT_SAFE +# define DISTRHO_PLUGIN_IS_RT_SAFE 1 +#endif + +#ifndef DISTRHO_UI_USE_NANOVG +# define DISTRHO_UI_USE_NANOVG 0 +#endif + #define DISTRHO_UI_URI DISTRHO_PLUGIN_URI "#UI" #endif // DISTRHO_PLUGIN_CHECKS_H_INCLUDED diff --git a/libs/distrho/src/DistrhoPluginInternal.hpp b/libs/distrho/src/DistrhoPluginInternal.hpp index c863284..a604c23 100644 --- a/libs/distrho/src/DistrhoPluginInternal.hpp +++ b/libs/distrho/src/DistrhoPluginInternal.hpp @@ -36,6 +36,8 @@ extern double d_lastSampleRate; // Plugin private data struct Plugin::PrivateData { + bool isProcessing; + uint32_t parameterCount; Parameter* parameters; @@ -61,7 +63,8 @@ struct Plugin::PrivateData { double sampleRate; PrivateData() noexcept - : parameterCount(0), + : isProcessing(false), + parameterCount(0), parameters(nullptr), #if DISTRHO_PLUGIN_WANT_PROGRAMS programCount(0), @@ -351,20 +354,27 @@ public: } #if DISTRHO_PLUGIN_IS_SYNTH - void run(float** const inputs, float** const outputs, const uint32_t frames, const MidiEvent* const midiEvents, const uint32_t midiEventCount) + void run(const float** const inputs, float** const outputs, const uint32_t frames, const MidiEvent* const midiEvents, const uint32_t midiEventCount) { + DISTRHO_SAFE_ASSERT_RETURN(fData != nullptr,); DISTRHO_SAFE_ASSERT_RETURN(fPlugin != nullptr,); + fData->isProcessing = true; fPlugin->d_run(inputs, outputs, frames, midiEvents, midiEventCount); + fData->isProcessing = false; } #else - void run(float** const inputs, float** const outputs, const uint32_t frames) + void run(const float** const inputs, float** const outputs, const uint32_t frames) { + DISTRHO_SAFE_ASSERT_RETURN(fData != nullptr,); DISTRHO_SAFE_ASSERT_RETURN(fPlugin != nullptr,); + fData->isProcessing = true; fPlugin->d_run(inputs, outputs, frames); + fData->isProcessing = false; } #endif + // ------------------------------------------------------------------- void setBufferSize(const uint32_t bufferSize, bool doCallback = false) @@ -407,7 +417,7 @@ public: private: // ------------------------------------------------------------------- - // private members accessed by DistrhoPlugin classes + // Plugin and DistrhoPlugin data Plugin* const fPlugin; Plugin::PrivateData* const fData; diff --git a/libs/distrho/src/DistrhoPluginJack.cpp b/libs/distrho/src/DistrhoPluginJack.cpp new file mode 100644 index 0000000..94155df --- /dev/null +++ b/libs/distrho/src/DistrhoPluginJack.cpp @@ -0,0 +1,425 @@ +/* + * DISTRHO Plugin Framework (DPF) + * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com> + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * For a full copy of the license see the LGPL.txt file + */ + +#include "DistrhoPluginInternal.hpp" + +#if ! DISTRHO_PLUGIN_HAS_UI +# error JACK export requires an UI +#endif + +#include "DistrhoUIInternal.hpp" + +#include "jack/jack.h" +#include "jack/midiport.h" +#include "jack/transport.h" + +// ----------------------------------------------------------------------- + +START_NAMESPACE_DISTRHO + +#if ! DISTRHO_PLUGIN_WANT_STATE +static const setStateFunc setStateCallback = nullptr; +#endif + +// ----------------------------------------------------------------------- + +class PluginJack : public IdleCallback +{ +public: + PluginJack(jack_client_t* const client) + : fPlugin(), + fUI(this, 0, nullptr, setParameterValueCallback, setStateCallback, nullptr, setSizeCallback, fPlugin.getInstancePointer()), + fClient(client) + { + char strBuf[0xff+1]; + strBuf[0xff] = '\0'; + +#if DISTRHO_PLUGIN_NUM_INPUTS > 0 + for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_INPUTS; ++i) + { + std::snprintf(strBuf, 0xff, "in%i", i+1); + fPortAudioIns[i] = jack_port_register(fClient, strBuf, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0); + } +#endif + +#if DISTRHO_PLUGIN_NUM_OUTPUTS > 0 + for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_OUTPUTS; ++i) + { + std::snprintf(strBuf, 0xff, "out%i", i+1); + fPortAudioOuts[i] = jack_port_register(fClient, strBuf, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); + } +#endif + +#if DISTRHO_PLUGIN_IS_SYNTH + fPortMidiIn = jack_port_register(fClient, "midi-in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0); +#endif + +#if DISTRHO_PLUGIN_WANT_PROGRAMS + if (fPlugin.getProgramCount() > 0) + fPlugin.setProgram(0); +#endif + + if (const uint32_t count = fPlugin.getParameterCount()) + { + fLastOutputValues = new float[count]; + + for (uint32_t i=0; i < count; ++i) + { + if (fPlugin.isParameterOutput(i)) + fLastOutputValues[i] = fPlugin.getParameterValue(i); + else + fLastOutputValues[i] = 0.0f; + } + } + else + { + fLastOutputValues = nullptr; + } + + jack_set_buffer_size_callback(fClient, jackBufferSizeCallback, this); + jack_set_sample_rate_callback(fClient, jackSampleRateCallback, this); + jack_set_process_callback(fClient, jackProcessCallback, this); + jack_on_shutdown(fClient, jackShutdownCallback, this); + + jack_activate(fClient); + + if (const char* const name = jack_get_client_name(fClient)) + fUI.setTitle(name); + else + fUI.setTitle(DISTRHO_PLUGIN_NAME); + + fUI.exec(this); + } + + ~PluginJack() + { + if (fClient == nullptr) + return; + + jack_deactivate(fClient); + +#if DISTRHO_PLUGIN_IS_SYNTH + jack_port_unregister(fClient, fPortMidiIn); + fPortMidiIn = nullptr; +#endif + +#if DISTRHO_PLUGIN_NUM_INPUTS > 0 + for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_INPUTS; ++i) + { + jack_port_unregister(fClient, fPortAudioIns[i]); + fPortAudioIns[i] = nullptr; + } +#endif + +#if DISTRHO_PLUGIN_NUM_OUTPUTS > 0 + for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_OUTPUTS; ++i) + { + jack_port_unregister(fClient, fPortAudioOuts[i]); + fPortAudioOuts[i] = nullptr; + } +#endif + + jack_client_close(fClient); + } + + // ------------------------------------------------------------------- + +protected: + void idleCallback() override + { + float value; + + for (uint32_t i=0, count=fPlugin.getParameterCount(); i < count; ++i) + { + if (! fPlugin.isParameterOutput(i)) + continue; + + value = fPlugin.getParameterValue(i); + + if (fLastOutputValues[i] == value) + continue; + + fLastOutputValues[i] = value; + fUI.parameterChanged(i, value); + } + + fUI.exec_idle(); + } + + void jackBufferSize(const jack_nframes_t nframes) + { + fPlugin.setBufferSize(nframes, true); + } + + void jackSampleRate(const jack_nframes_t nframes) + { + fPlugin.setSampleRate(nframes, true); + } + + void jackProcess(const jack_nframes_t nframes) + { +#if DISTRHO_PLUGIN_NUM_INPUTS > 0 + const float* audioIns[DISTRHO_PLUGIN_NUM_INPUTS]; + + for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_INPUTS; ++i) + audioIns[i] = (const float*)jack_port_get_buffer(fPortAudioIns[i], nframes); +#else + static const float** audioIns = nullptr; +#endif + +#if DISTRHO_PLUGIN_NUM_OUTPUTS > 0 + float* audioOuts[DISTRHO_PLUGIN_NUM_OUTPUTS]; + + for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_OUTPUTS; ++i) + audioOuts[i] = (float*)jack_port_get_buffer(fPortAudioOuts[i], nframes); +#else + static float** audioOuts = nullptr; +#endif + +#if DISTRHO_PLUGIN_WANT_TIMEPOS + jack_position_t pos; + fTimePos.playing = (jack_transport_query(fClient, &pos) == JackTransportRolling); + + if (pos.unique_1 == pos.unique_2) + { + if (pos.valid & JackTransportPosition) + fTimePos.frame = pos.frame; + else + fTimePos.frame = 0; + + if (pos.valid & JackTransportBBT) + { + fTimePos.bbt.valid = true; + + fTimePos.bbt.bar = pos.bar; + fTimePos.bbt.beat = pos.beat; + fTimePos.bbt.tick = pos.tick; + fTimePos.bbt.barStartTick = pos.bar_start_tick; + + fTimePos.bbt.beatsPerBar = pos.beats_per_bar; + fTimePos.bbt.beatType = pos.beat_type; + + fTimePos.bbt.ticksPerBeat = pos.ticks_per_beat; + fTimePos.bbt.beatsPerMinute = pos.beats_per_minute; + } + else + fTimePos.bbt.valid = false; + } + else + { + fTimePos.bbt.valid = false; + fTimePos.frame = 0; + } + + fPlugin.setTimePos(fTimePos); +#endif + +#if DISTRHO_PLUGIN_IS_SYNTH + void* const midiBuf = jack_port_get_buffer(fPortMidiIn, nframes); + + if (const uint32_t eventCount = jack_midi_get_event_count(midiBuf)) + { + uint32_t midiEventCount = 0; + MidiEvent midiEvents[eventCount]; + + jack_midi_event_t jevent; + + for (uint32_t i=0; i < eventCount; ++i) + { + if (jack_midi_event_get(&jevent, midiBuf, i) != 0) + break; + if (jevent.size > 4) + continue; + + MidiEvent& midiEvent(midiEvents[midiEventCount++]); + + midiEvent.frame = jevent.time; + midiEvent.size = jevent.size; + std::memcpy(midiEvent.buf, jevent.buffer, jevent.size); + } + + fPlugin.run(audioIns, audioOuts, nframes, midiEvents, midiEventCount); + } + else + { + fPlugin.run(audioIns, audioOuts, nframes, nullptr, 0); + } +#else + fPlugin.run(audioIns, audioOuts, nframes); +#endif + } + + void jackShutdown() + { + d_stderr("jack has shutdown, quitting now..."); + fClient = nullptr; + fUI.quit(); + } + + // ------------------------------------------------------------------- + + void setParameterValue(const uint32_t index, const float value) + { + fPlugin.setParameterValue(index, value); + } + +#if DISTRHO_PLUGIN_WANT_STATE + void setState(const char* const key, const char* const value) + { + fPlugin.setState(key, value); + } +#endif + + void setSize(const uint width, const uint height) + { + fUI.setSize(width, height); + } + + // ------------------------------------------------------------------- + +private: + PluginExporter fPlugin; + UIExporter fUI; + + jack_client_t* fClient; + +#if DISTRHO_PLUGIN_NUM_INPUTS > 0 + jack_port_t* fPortAudioIns[DISTRHO_PLUGIN_NUM_INPUTS]; +#endif +#if DISTRHO_PLUGIN_NUM_OUTPUTS > 0 + jack_port_t* fPortAudioOuts[DISTRHO_PLUGIN_NUM_OUTPUTS]; +#endif +#if DISTRHO_PLUGIN_IS_SYNTH + jack_port_t* fPortMidiIn; +#endif +#if DISTRHO_PLUGIN_WANT_TIMEPOS + TimePos fTimePos; +#endif + + // Temporary data + float* fLastOutputValues; + + // ------------------------------------------------------------------- + // Callbacks + + #define uiPtr ((PluginJack*)ptr) + + static int jackBufferSizeCallback(jack_nframes_t nframes, void* ptr) + { + uiPtr->jackBufferSize(nframes); + return 0; + } + + static int jackSampleRateCallback(jack_nframes_t nframes, void* ptr) + { + uiPtr->jackSampleRate(nframes); + return 0; + } + + static int jackProcessCallback(jack_nframes_t nframes, void* ptr) + { + uiPtr->jackProcess(nframes); + return 0; + } + + static void jackShutdownCallback(void* ptr) + { + uiPtr->jackShutdown(); + } + + static void setParameterValueCallback(void* ptr, uint32_t index, float value) + { + uiPtr->setParameterValue(index, value); + } + +#if DISTRHO_PLUGIN_WANT_STATE + static void setStateCallback(void* ptr, const char* key, const char* value) + { + uiPtr->setState(key, value); + } +#endif + + static void setSizeCallback(void* ptr, uint width, uint height) + { + uiPtr->setSize(width, height); + } + + #undef uiPtr +}; + +END_NAMESPACE_DISTRHO + +// ----------------------------------------------------------------------- + +int main() +{ + jack_status_t status = jack_status_t(0x0); + jack_client_t* client = jack_client_open(DISTRHO_PLUGIN_NAME, JackNoStartServer, &status); + + if (client == nullptr) + { + d_string errorString; + + if (status & JackFailure) + errorString += "Overall operation failed;\n"; + if (status & JackInvalidOption) + errorString += "The operation contained an invalid or unsupported option;\n"; + if (status & JackNameNotUnique) + errorString += "The desired client name was not unique;\n"; + if (status & JackServerStarted) + errorString += "The JACK server was started as a result of this operation;\n"; + if (status & JackServerFailed) + errorString += "Unable to connect to the JACK server;\n"; + if (status & JackServerError) + errorString += "Communication error with the JACK server;\n"; + if (status & JackNoSuchClient) + errorString += "Requested client does not exist;\n"; + if (status & JackLoadFailure) + errorString += "Unable to load internal client;\n"; + if (status & JackInitFailure) + errorString += "Unable to initialize client;\n"; + if (status & JackShmFailure) + errorString += "Unable to access shared memory;\n"; + if (status & JackVersionError) + errorString += "Client's protocol version does not match;\n"; + if (status & JackBackendError) + errorString += "Backend Error;\n"; + if (status & JackClientZombie) + errorString += "Client is being shutdown against its will;\n"; + + if (errorString.isNotEmpty()) + { + errorString[errorString.length()-2] = '.'; + d_stderr("Failed to create jack client, reason was:\n%s", errorString.buffer()); + } + else + d_stderr("Failed to create jack client, cannot continue!"); + + return 1; + } + + USE_NAMESPACE_DISTRHO; + + d_lastBufferSize = jack_get_buffer_size(client); + d_lastSampleRate = jack_get_sample_rate(client); + d_lastUiSampleRate = d_lastSampleRate; + + const PluginJack p(client); + + return 0; +} + +// ----------------------------------------------------------------------- diff --git a/libs/distrho/src/DistrhoPluginLADSPA+DSSI.cpp b/libs/distrho/src/DistrhoPluginLADSPA+DSSI.cpp index e79ffeb..0cb062d 100644 --- a/libs/distrho/src/DistrhoPluginLADSPA+DSSI.cpp +++ b/libs/distrho/src/DistrhoPluginLADSPA+DSSI.cpp @@ -334,9 +334,9 @@ private: // LADSPA ports #if DISTRHO_PLUGIN_NUM_INPUTS > 0 - LADSPA_Data* fPortAudioIns[DISTRHO_PLUGIN_NUM_INPUTS]; + const LADSPA_Data* fPortAudioIns[DISTRHO_PLUGIN_NUM_INPUTS]; #else - LADSPA_Data** fPortAudioIns; + const LADSPA_Data** fPortAudioIns; #endif #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0 LADSPA_Data* fPortAudioOuts[DISTRHO_PLUGIN_NUM_OUTPUTS]; @@ -446,7 +446,11 @@ static void dssi_run_synth(LADSPA_Handle instance, ulong sampleCount, snd_seq_ev static LADSPA_Descriptor sLadspaDescriptor = { /* UniqueID */ 0, /* Label */ nullptr, +#if DISTRHO_PLUGIN_IS_RT_SAFE /* Properties */ LADSPA_PROPERTY_HARD_RT_CAPABLE, +#else + /* Properties */ 0x0, +#endif /* Name */ nullptr, /* Maker */ nullptr, /* Copyright */ nullptr, diff --git a/libs/distrho/src/DistrhoPluginLV2.cpp b/libs/distrho/src/DistrhoPluginLV2.cpp index ffb7591..1a04e52 100644 --- a/libs/distrho/src/DistrhoPluginLV2.cpp +++ b/libs/distrho/src/DistrhoPluginLV2.cpp @@ -175,7 +175,7 @@ public: { if (port == index++) { - fPortAudioIns[i] = (float*)dataLocation; + fPortAudioIns[i] = (const float*)dataLocation; return; } } @@ -677,9 +677,9 @@ private: // LV2 ports #if DISTRHO_PLUGIN_NUM_INPUTS > 0 - float* fPortAudioIns[DISTRHO_PLUGIN_NUM_INPUTS]; + const float* fPortAudioIns[DISTRHO_PLUGIN_NUM_INPUTS]; #else - float** fPortAudioIns; + const float** fPortAudioIns; #endif #if DISTRHO_PLUGIN_NUM_OUTPUTS > 0 float* fPortAudioOuts[DISTRHO_PLUGIN_NUM_OUTPUTS]; diff --git a/libs/distrho/src/DistrhoPluginLV2export.cpp b/libs/distrho/src/DistrhoPluginLV2export.cpp index 780c615..189d941 100644 --- a/libs/distrho/src/DistrhoPluginLV2export.cpp +++ b/libs/distrho/src/DistrhoPluginLV2export.cpp @@ -166,8 +166,12 @@ void lv2_generate_ttl(const char* const basename) pluginString += ";\n\n"; // optionalFeatures +#if DISTRHO_PLUGIN_IS_RT_SAFE pluginString += " lv2:optionalFeature <" LV2_CORE__hardRTCapable "> ,\n"; pluginString += " <" LV2_BUF_SIZE__boundedBlockLength "> ;\n"; +#else + pluginString += " lv2:optionalFeature <" LV2_BUF_SIZE__boundedBlockLength "> ;\n"; +#endif pluginString += "\n"; // requiredFeatures diff --git a/libs/distrho/src/DistrhoPluginVST.cpp b/libs/distrho/src/DistrhoPluginVST.cpp index 5eb1954..0747661 100644 --- a/libs/distrho/src/DistrhoPluginVST.cpp +++ b/libs/distrho/src/DistrhoPluginVST.cpp @@ -119,7 +119,7 @@ public: fEffect(effect), fUiHelper(uiHelper), fPlugin(plugin), - fUI(this, winId, editParameterCallback, setParameterCallback, setStateCallback, sendNoteCallback, uiResizeCallback, plugin->getInstancePointer()) + fUI(this, winId, editParameterCallback, setParameterCallback, setStateCallback, sendNoteCallback, setSizeCallback, plugin->getInstancePointer()) { } @@ -215,7 +215,7 @@ protected: #endif } - void uiResize(const uint width, const uint height) + void setSize(const uint width, const uint height) { fUI.setSize(width, height); hostCallback(audioMasterSizeWindow, width, height, nullptr, 0.0f); @@ -256,9 +256,9 @@ private: handlePtr->sendNote(channel, note, velocity); } - static void uiResizeCallback(void* ptr, uint width, uint height) + static void setSizeCallback(void* ptr, uint width, uint height) { - handlePtr->uiResize(width, height); + handlePtr->setSize(width, height); } #undef handlePtr @@ -638,24 +638,23 @@ public: #endif } - void vst_processReplacing(float** const inputs, float** const outputs, const int32_t sampleFrames) + void vst_processReplacing(const float** const inputs, float** const outputs, const int32_t sampleFrames) { #if DISTRHO_PLUGIN_WANT_TIMEPOS - static const int kWantedVstTimeFlags(kVstTransportPlaying|kVstTempoValid|kVstTimeSigValid); + static const int kWantVstTimeFlags(kVstTransportPlaying|kVstTempoValid|kVstTimeSigValid); - if (const VstTimeInfo* const vstTimeInfo = (const VstTimeInfo*)fAudioMaster(fEffect, audioMasterGetTime, 0, kWantedVstTimeFlags, nullptr, 0.0f)) + if (const VstTimeInfo* const vstTimeInfo = (const VstTimeInfo*)fAudioMaster(fEffect, audioMasterGetTime, 0, kWantVstTimeFlags, nullptr, 0.0f)) { fTimePos.playing = (vstTimeInfo->flags & kVstTransportPlaying); fTimePos.frame = vstTimeInfo->samplePos; + fTimePos.bbt.valid = ((vstTimeInfo->flags & kVstTempoValid) != 0 || (vstTimeInfo->flags & kVstTimeSigValid) != 0); if (vstTimeInfo->flags & kVstTempoValid) { - fTimePos.bbt.valid = true; fTimePos.bbt.beatsPerMinute = vstTimeInfo->tempo; } if (vstTimeInfo->flags & kVstTimeSigValid) { - fTimePos.bbt.valid = true; fTimePos.bbt.beatsPerBar = vstTimeInfo->timeSigNumerator; fTimePos.bbt.beatType = vstTimeInfo->timeSigDenominator; } @@ -736,8 +735,7 @@ private: { # if DISTRHO_PLUGIN_HAS_UI // set previous parameters invalid - for (uint32_t i=0, count = fPlugin.getParameterCount(); i < count; ++i) - parameterChecks[i] = false; + std::memset(parameterChecks, 0, sizeof(bool)*fPlugin.getParameterCount()); # endif nextProgram = index; @@ -939,13 +937,13 @@ static void vst_setParameterCallback(AEffect* effect, int32_t index, float value static void vst_processCallback(AEffect* effect, float** inputs, float** outputs, int32_t sampleFrames) { if (validEffect) - handlePtr->vst_processReplacing(inputs, outputs, sampleFrames); + handlePtr->vst_processReplacing(const_cast<const float**>(inputs), outputs, sampleFrames); } static void vst_processReplacingCallback(AEffect* effect, float** inputs, float** outputs, int32_t sampleFrames) { if (validEffect) - handlePtr->vst_processReplacing(inputs, outputs, sampleFrames); + handlePtr->vst_processReplacing(const_cast<const float**>(inputs), outputs, sampleFrames); } #undef handlePtr @@ -955,6 +953,13 @@ static void vst_processReplacingCallback(AEffect* effect, float** inputs, float* END_NAMESPACE_DISTRHO DISTRHO_PLUGIN_EXPORT +#if DISTRHO_OS_WINDOWS +const AEffect* VSTPluginMain(audioMasterCallback audioMaster); +#else +const AEffect* VSTPluginMain(audioMasterCallback audioMaster) asm ("main"); +#endif + +DISTRHO_PLUGIN_EXPORT const AEffect* VSTPluginMain(audioMasterCallback audioMaster) { USE_NAMESPACE_DISTRHO @@ -977,7 +982,7 @@ const AEffect* VSTPluginMain(audioMasterCallback audioMaster) int32_t* const version = (int32_t*)&effect->unknown1; *version = plugin->getVersion(); #else - effect->version = plugin->getVersion(); + effect->version = plugin->getVersion(); #endif // plugin fields @@ -1016,3 +1021,5 @@ const AEffect* VSTPluginMain(audioMasterCallback audioMaster) return effect; } + +// ----------------------------------------------------------------------- diff --git a/libs/distrho/src/DistrhoUI.cpp b/libs/distrho/src/DistrhoUI.cpp index a015675..a2e0368 100644 --- a/libs/distrho/src/DistrhoUI.cpp +++ b/libs/distrho/src/DistrhoUI.cpp @@ -31,12 +31,14 @@ double d_lastUiSampleRate = 0.0; // UI UI::UI() - : DGL::Widget(*DGL::dgl_lastUiParent), + : UIWidget(*DGL::dgl_lastUiParent), pData(new PrivateData()) { DISTRHO_SAFE_ASSERT(DGL::dgl_lastUiParent != nullptr); DGL::dgl_lastUiParent = nullptr; + + Widget::setNeedsFullViewport(true); } UI::~UI() @@ -79,9 +81,9 @@ void UI::d_sendNote(uint8_t channel, uint8_t note, uint8_t velocity) // ----------------------------------------------------------------------- // Host UI State -void UI::d_uiResize(uint width, uint height) +void UI::d_setSize(uint width, uint height) { - pData->uiResizeCallback(width, height); + pData->setSizeCallback(width, height); } #if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS @@ -95,5 +97,20 @@ void* UI::d_getPluginInstancePointer() const noexcept #endif // ----------------------------------------------------------------------- +// UI Callbacks (optional) + +void UI::d_uiReshape(int width, int height) +{ + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(0, width, height, 0, 0.0f, 1.0f); + glViewport(0, 0, width, height); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); +} + +// ----------------------------------------------------------------------- END_NAMESPACE_DISTRHO diff --git a/libs/distrho/src/DistrhoUIDSSI.cpp b/libs/distrho/src/DistrhoUIDSSI.cpp index fe1fb09..4747035 100644 --- a/libs/distrho/src/DistrhoUIDSSI.cpp +++ b/libs/distrho/src/DistrhoUIDSSI.cpp @@ -20,6 +20,8 @@ # error DSSI UIs do not support direct access! #endif +#include "../extra/d_sleep.hpp" + #include <lo/lo.h> START_NAMESPACE_DISTRHO @@ -91,7 +93,7 @@ class UIDssi { public: UIDssi(const OscData& oscData, const char* const uiTitle) - : fUI(this, 0, nullptr, setParameterCallback, setStateCallback, sendNoteCallback, uiResizeCallback), + : fUI(this, 0, nullptr, setParameterCallback, setStateCallback, sendNoteCallback, setSizeCallback), fHostClosed(false), fOscData(oscData) { @@ -113,7 +115,7 @@ public: if (! fUI.idle()) break; - d_msleep(50); + d_msleep(30); } } @@ -186,7 +188,7 @@ protected: fOscData.send_midi(mdata); } - void uiResize(const uint width, const uint height) + void setSize(const uint width, const uint height) { fUI.setSize(width, height); } @@ -217,9 +219,9 @@ private: uiPtr->sendNote(channel, note, velocity); } - static void uiResizeCallback(void* ptr, uint width, uint height) + static void setSizeCallback(void* ptr, uint width, uint height) { - uiPtr->uiResize(width, height); + uiPtr->setSize(width, height); } #undef uiPtr diff --git a/libs/distrho/src/DistrhoUIInternal.hpp b/libs/distrho/src/DistrhoUIInternal.hpp index e398624..00cddf8 100644 --- a/libs/distrho/src/DistrhoUIInternal.hpp +++ b/libs/distrho/src/DistrhoUIInternal.hpp @@ -22,6 +22,10 @@ #include "../../dgl/App.hpp" #include "../../dgl/Window.hpp" +using DGL::App; +using DGL::IdleCallback; +using DGL::Window; + START_NAMESPACE_DISTRHO // ----------------------------------------------------------------------- @@ -36,7 +40,7 @@ typedef void (*editParamFunc) (void* ptr, uint32_t rindex, bool started); typedef void (*setParamFunc) (void* ptr, uint32_t rindex, float value); typedef void (*setStateFunc) (void* ptr, const char* key, const char* value); typedef void (*sendNoteFunc) (void* ptr, uint8_t channel, uint8_t note, uint8_t velo); -typedef void (*uiResizeFunc) (void* ptr, uint width, uint height); +typedef void (*setSizeFunc) (void* ptr, uint width, uint height); // ----------------------------------------------------------------------- // UI private data @@ -54,7 +58,7 @@ struct UI::PrivateData { setParamFunc setParamCallbackFunc; setStateFunc setStateCallbackFunc; sendNoteFunc sendNoteCallbackFunc; - uiResizeFunc uiResizeCallbackFunc; + setSizeFunc setSizeCallbackFunc; void* ptr; PrivateData() noexcept @@ -67,7 +71,7 @@ struct UI::PrivateData { setParamCallbackFunc(nullptr), setStateCallbackFunc(nullptr), sendNoteCallbackFunc(nullptr), - uiResizeCallbackFunc(nullptr), + setSizeCallbackFunc(nullptr), ptr(nullptr) { DISTRHO_SAFE_ASSERT(sampleRate != 0.0); @@ -113,11 +117,59 @@ struct UI::PrivateData { sendNoteCallbackFunc(ptr, channel, note, velocity); } - void uiResizeCallback(const uint width, const uint height) + void setSizeCallback(const uint width, const uint height) + { + if (setSizeCallbackFunc != nullptr) + setSizeCallbackFunc(ptr, width, height); + } +}; + +// ----------------------------------------------------------------------- +// Plugin Window, needed to take care of resize properly + +class UIExporterWindow : public Window +{ +public: + UIExporterWindow(App& app, const intptr_t winId) + : Window(app, winId), + fUi(createUI()), + fIsReady(false) + { + DISTRHO_SAFE_ASSERT_RETURN(fUi != nullptr,); + + setResizable(false); + setSize(fUi->d_getWidth(), fUi->d_getHeight()); + } + + ~UIExporterWindow() + { + delete fUi; + } + + UI* getUI() const noexcept + { + return fUi; + } + + bool isReady() const noexcept + { + return fIsReady; + } + +protected: + void onReshape(int width, int height) override { - if (uiResizeCallbackFunc != nullptr) - uiResizeCallbackFunc(ptr, width, height); + DISTRHO_SAFE_ASSERT_RETURN(fUi != nullptr,); + + fIsReady = true; + + fUi->setSize(width, height); + fUi->d_uiReshape(width, height); } + +private: + UI* const fUi; + bool fIsReady; }; // ----------------------------------------------------------------------- @@ -127,11 +179,11 @@ class UIExporter { public: UIExporter(void* const ptr, const intptr_t winId, - const editParamFunc editParamCall, const setParamFunc setParamCall, const setStateFunc setStateCall, const sendNoteFunc sendNoteCall, const uiResizeFunc uiResizeCall, + const editParamFunc editParamCall, const setParamFunc setParamCall, const setStateFunc setStateCall, const sendNoteFunc sendNoteCall, const setSizeFunc setSizeCall, void* const dspPtr = nullptr) : glApp(), glWindow(glApp, winId), - fUi(createUI()), + fUi(glWindow.getUI()), fData((fUi != nullptr) ? fUi->pData : nullptr) { DISTRHO_SAFE_ASSERT_RETURN(fUi != nullptr,); @@ -142,10 +194,7 @@ public: fData->setParamCallbackFunc = setParamCall; fData->setStateCallbackFunc = setStateCall; fData->sendNoteCallbackFunc = sendNoteCall; - fData->uiResizeCallbackFunc = uiResizeCall; - - glWindow.setSize(fUi->d_getWidth(), fUi->d_getHeight()); - glWindow.setResizable(false); + fData->setSizeCallbackFunc = setSizeCall; #if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS fData->dspPtr = dspPtr; @@ -155,11 +204,6 @@ public: #endif } - ~UIExporter() - { - delete fUi; - } - // ------------------------------------------------------------------- const char* getName() const noexcept @@ -223,13 +267,31 @@ public: // ------------------------------------------------------------------- + void exec(IdleCallback* const cb) + { + DISTRHO_SAFE_ASSERT_RETURN(cb != nullptr,); + DISTRHO_SAFE_ASSERT_RETURN(fUi != nullptr,); + + glWindow.addIdleCallback(cb); + glWindow.setVisible(true); + glApp.exec(); + } + + void exec_idle() + { + if (glWindow.isReady()) + fUi->d_uiIdle(); + } + bool idle() { DISTRHO_SAFE_ASSERT_RETURN(fUi != nullptr, false); - fUi->d_uiIdle(); glApp.idle(); + if (glWindow.isReady()) + fUi->d_uiIdle(); + return ! glApp.isQuiting(); } @@ -268,19 +330,18 @@ public: private: // ------------------------------------------------------------------- - // DGL Application and Window for this plugin + // DGL Application and Window for this widget - DGL::App glApp; - DGL::Window glWindow; + App glApp; + UIExporterWindow glWindow; // ------------------------------------------------------------------- - // private members accessed by DistrhoUI classes + // Widget and DistrhoUI data UI* const fUi; UI::PrivateData* const fData; DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(UIExporter) - DISTRHO_PREVENT_HEAP_ALLOCATION }; // ----------------------------------------------------------------------- diff --git a/libs/distrho/src/DistrhoUILV2.cpp b/libs/distrho/src/DistrhoUILV2.cpp index 1e8aa36..93feefb 100644 --- a/libs/distrho/src/DistrhoUILV2.cpp +++ b/libs/distrho/src/DistrhoUILV2.cpp @@ -37,7 +37,7 @@ public: UiLv2(const intptr_t winId, const LV2_Options_Option* options, const LV2_URID_Map* const uridMap, const LV2UI_Resize* const uiResz, const LV2UI_Touch* uiTouch, const LV2UI_Controller controller, const LV2UI_Write_Function writeFunc, void* const dspPtr) - : fUI(this, winId, editParameterCallback, setParameterCallback, setStateCallback, sendNoteCallback, uiResizeCallback, dspPtr), + : fUI(this, winId, editParameterCallback, setParameterCallback, setStateCallback, sendNoteCallback, setSizeCallback, dspPtr), fUridMap(uridMap), fUiResize(uiResz), fUiTouch(uiTouch), @@ -193,7 +193,7 @@ protected: { } - void uiResize(const uint width, const uint height) + void setSize(const uint width, const uint height) { fUI.setSize(width, height); @@ -245,9 +245,9 @@ private: uiPtr->sendNote(channel, note, velocity); } - static void uiResizeCallback(void* ptr, uint width, uint height) + static void setSizeCallback(void* ptr, uint width, uint height) { - uiPtr->uiResize(width, height); + uiPtr->setSize(width, height); } #undef uiPtr diff --git a/libs/generate-ttl.sh b/libs/generate-ttl.sh index 76b9b04..2515e11 100755 --- a/libs/generate-ttl.sh +++ b/libs/generate-ttl.sh @@ -9,17 +9,18 @@ else exit fi -PWD=`pwd` +PWD=`dirname $0` -if [ -f $PWD/../libs/lv2_ttl_generator.exe ]; then - GEN=$PWD/../libs/lv2_ttl_generator.exe +if [ -f ../../$PWD/lv2_ttl_generator.exe ]; then + GEN=../../$PWD/lv2_ttl_generator.exe EXT=dll -elif [ -d /Developer ]; then - GEN=$PWD/../libs/lv2_ttl_generator - EXT=dylib else - GEN=$PWD/../libs/lv2_ttl_generator - EXT=so + GEN=../../$PWD/lv2_ttl_generator + if [ -d /Library/Audio ]; then + EXT=dylib + else + EXT=so + fi fi FOLDERS=`find . -type d -name \*.lv2` diff --git a/plugins/ImageToggle.hpp b/plugins/ImageToggle.hpp new file mode 100644 index 0000000..b3800f0 --- /dev/null +++ b/plugins/ImageToggle.hpp @@ -0,0 +1,148 @@ +/* + * DISTRHO Plugin Framework (DPF) + * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com> + * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> + * + * Permission to use, copy, modify, and/or distribute this software for any purpose with + * or without fee is hereby granted, provided that the above copyright notice and this + * permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD + * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN + * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER + * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef DGL_IMAGE_TOGGLE_HPP_INCLUDED +#define DGL_IMAGE_TOGGLE_HPP_INCLUDED + +#include "Image.hpp" +#include "Widget.hpp" + +START_NAMESPACE_DGL + +// ----------------------------------------------------------------------- + +class ImageToggle : public Widget +{ +public: + class Callback + { + public: + virtual ~Callback() {} + virtual void imageToggleClicked(ImageToggle* imageToggle, int button) = 0; + }; + + ImageToggle(Window& parent, const Image& imageNormal, const Image& imageDown, int id = 0) + : Widget(parent), + fImageNormal(imageNormal), + fImageDown(imageDown), + fCurImage(&fImageNormal), + fId(id), + fCallback(nullptr) + { + DISTRHO_SAFE_ASSERT(fImageNormal.getSize() == fImageDown.getSize()); + + setSize(fImageNormal.getSize()); + } + + ImageToggle(Widget* widget, const Image& imageNormal, const Image& imageDown, int id = 0) + : Widget(widget->getParentWindow()), + fImageNormal(imageNormal), + fImageDown(imageDown), + fCurImage(&fImageNormal), + fId(id), + fCallback(nullptr) + { + DISTRHO_SAFE_ASSERT(fImageNormal.getSize() == fImageDown.getSize()); + + setSize(fImageNormal.getSize()); + } + + ImageToggle(const ImageToggle& imageToggle) + : Widget(imageToggle.getParentWindow()), + fImageNormal(imageToggle.fImageNormal), + fImageDown(imageToggle.fImageDown), + fCurImage(&fImageNormal), + fId(imageToggle.fId), + fCallback(imageToggle.fCallback) + { + DISTRHO_SAFE_ASSERT(fImageNormal.getSize() == fImageDown.getSize()); + + setSize(fImageNormal.getSize()); + } + + int getId() const noexcept + { + return fId; + } + + void setId(int id) noexcept + { + fId = id; + } + + float getValue() const noexcept + { + return (fCurImage == &fImageNormal) ? 0.0f : 1.0f; + } + + void setValue(float value) noexcept + { + if (value == 1.0f) + fCurImage = &fImageDown; + else if (value == 0.0f) + fCurImage = &fImageNormal; + + repaint(); + } + + void setCallback(Callback* callback) noexcept + { + fCallback = callback; + } + +protected: + void onDisplay() override + { + fCurImage->draw(); + } + + bool onMouse(const MouseEvent& ev) override + { + if (! ev.press) + return false; + if (! contains(ev.pos)) + return false; + + if (fCurImage != &fImageDown) + fCurImage = &fImageDown; + else if (fCurImage != &fImageNormal) + fCurImage = &fImageNormal; + + repaint(); + + if (fCallback != nullptr) + fCallback->imageToggleClicked(this, ev.button); + + return true; + } + +private: + Image fImageNormal; + Image fImageDown; + Image* fCurImage; + int fId; + + Callback* fCallback; + + DISTRHO_LEAK_DETECTOR(ImageToggle) +}; + +// ----------------------------------------------------------------------- + +END_NAMESPACE_DGL + +#endif // DGL_IMAGE_TOGGLE_HPP_INCLUDED diff --git a/plugins/Makefile.mk b/plugins/Makefile.mk index aa405da..340de08 100644 --- a/plugins/Makefile.mk +++ b/plugins/Makefile.mk @@ -14,21 +14,17 @@ include ../../Makefile.mk TARGET_DIR = ../../bin BUILD_C_FLAGS += -I. -BUILD_CXX_FLAGS += -I. -I../../libs/distrho -I../../libs/dgl - -# -------------------------------------------------------------- -# Enable all plugin types - -#all: dssi lv2 vst -all: lv2 +BUILD_CXX_FLAGS += -I. -I.. -I../../libs/distrho -I../../libs/dgl # -------------------------------------------------------------- # Set plugin binary file targets +jack = $(TARGET_DIR)/$(NAME) ladspa_dsp = $(TARGET_DIR)/$(NAME)-ladspa.$(EXT) dssi_dsp = $(TARGET_DIR)/$(NAME)-dssi.$(EXT) dssi_ui = $(TARGET_DIR)/$(NAME)-dssi/$(NAME)_ui -lv2_dsp = $(TARGET_DIR)/$(NAME).lv2/$(NAME).$(EXT) +lv2 = $(TARGET_DIR)/$(NAME).lv2/$(NAME).$(EXT) +lv2_dsp = $(TARGET_DIR)/$(NAME).lv2/$(NAME)_dsp.$(EXT) lv2_ui = $(TARGET_DIR)/$(NAME).lv2/$(NAME)_ui.$(EXT) vst = $(TARGET_DIR)/$(NAME)-vst.$(EXT) @@ -56,17 +52,31 @@ OBJS_UI = endif # -------------------------------------------------------------- +# all needs to be first + +all: + +# -------------------------------------------------------------- # Common %.c.o: %.c - $(CXX) $< $(BUILD_CXX_FLAGS) -c -o $@ + $(CC) $< $(BUILD_C_FLAGS) -c -o $@ %.cpp.o: %.cpp $(CXX) $< $(BUILD_CXX_FLAGS) -c -o $@ clean: - $(RM) *.o - $(RM) -r $(TARGET_DIR)/$(NAME)-* $(TARGET_DIR)/$(NAME).lv2/ + rm -f *.o + rm -rf $(TARGET_DIR)/$(NAME) $(TARGET_DIR)/$(NAME)-* $(TARGET_DIR)/$(NAME).lv2/ + +# -------------------------------------------------------------- +# JACK + +jack: $(jack) + +$(jack): $(OBJS_DSP) $(OBJS_UI) $(DISTRHO_PLUGIN_FILES) $(DISTRHO_UI_FILES) + mkdir -p $(shell dirname $@) + $(CXX) $^ $(BUILD_CXX_FLAGS) $(LINK_FLAGS) $(DGL_LIBS) $(shell pkg-config --cflags --libs jack) -DDISTRHO_PLUGIN_TARGET_JACK -o $@ # -------------------------------------------------------------- # LADSPA @@ -93,7 +103,12 @@ $(dssi_ui): $(OBJS_UI) $(DISTRHO_UI_FILES) # -------------------------------------------------------------- # LV2 -lv2: $(lv2_dsp) $(lv2_ui) +lv2_one: $(lv2) +lv2_sep: $(lv2_dsp) $(lv2_ui) + +$(lv2): $(OBJS_DSP) $(OBJS_UI) $(DISTRHO_PLUGIN_FILES) $(DISTRHO_UI_FILES) + mkdir -p $(shell dirname $@) + $(CXX) $^ $(BUILD_CXX_FLAGS) $(LINK_FLAGS) $(DGL_LIBS) $(SHARED) -DDISTRHO_PLUGIN_TARGET_LV2 -o $@ $(lv2_dsp): $(OBJS_DSP) $(DISTRHO_PLUGIN_FILES) mkdir -p $(shell dirname $@) diff --git a/plugins/ZaMultiComp/Makefile b/plugins/ZaMultiComp/Makefile index 2250367..76410ac 100644 --- a/plugins/ZaMultiComp/Makefile +++ b/plugins/ZaMultiComp/Makefile @@ -20,13 +20,17 @@ OBJS_UI = \ ZaMultiCompUI.cpp.o # -------------------------------------------------------------- -# No custom UI for now +# Do some magic -#TARGET_NOUI = true +include ../Makefile.mk # -------------------------------------------------------------- -# Do some magic +# Enable all possible plugin types -include ../Makefile.mk +ifeq ($(LINUX),true) +all: jack ladspa dssi lv2_sep vst +else +all: ladspa dssi lv2_sep vst +endif # -------------------------------------------------------------- diff --git a/plugins/ZaMultiComp/ZaMultiCompPlugin.cpp b/plugins/ZaMultiComp/ZaMultiCompPlugin.cpp index 84f9b7f..003c007 100644 --- a/plugins/ZaMultiComp/ZaMultiCompPlugin.cpp +++ b/plugins/ZaMultiComp/ZaMultiCompPlugin.cpp @@ -26,13 +26,6 @@ ZaMultiCompPlugin::ZaMultiCompPlugin() { // set default values d_setProgram(0); - - // reset - d_deactivate(); -} - -ZaMultiCompPlugin::~ZaMultiCompPlugin() -{ } // ----------------------------------------------------------------------- @@ -451,11 +444,6 @@ void ZaMultiCompPlugin::d_activate() } } -void ZaMultiCompPlugin::d_deactivate() -{ - // all values to zero -} - float ZaMultiCompPlugin::run_filter(int i, float in) { in = sanitize_denormal(in); @@ -488,14 +476,14 @@ void ZaMultiCompPlugin::set_lp_coeffs(float fc, float q, float sr, int i, float b2[i] = (float)((1.f - alpha)*inv); } -void ZaMultiCompPlugin::set_hp_coeffs(float fc, float q, float sr, int i, float gain=1.0) -{ +void ZaMultiCompPlugin::set_hp_coeffs(float fc, float q, float sr, int i, float gain=1.0) +{ float omega=(float)(2.f*M_PI*fc/sr); float sn=sin(omega); float cs=cos(omega); float alpha=(float)(sn/(2.f*q)); float inv=(float)(1.f/(1.f+alpha)); - + a0[i] = (float)(gain*inv*(1.f + cs)/2.f); a1[i] = -2.f * a0[i]; a2[i] = a0[i]; @@ -551,7 +539,7 @@ float ZaMultiCompPlugin::run_comp(int k, float in) return sanitize_denormal(out); } -void ZaMultiCompPlugin::d_run(float** inputs, float** outputs, uint32_t frames) +void ZaMultiCompPlugin::d_run(const float** inputs, float** outputs, uint32_t frames) { float srate = d_getSampleRate(); float max = 0.f; diff --git a/plugins/ZaMultiComp/ZaMultiCompPlugin.hpp b/plugins/ZaMultiComp/ZaMultiCompPlugin.hpp index d3d12ca..da25b94 100644 --- a/plugins/ZaMultiComp/ZaMultiCompPlugin.hpp +++ b/plugins/ZaMultiComp/ZaMultiCompPlugin.hpp @@ -66,7 +66,6 @@ public: }; ZaMultiCompPlugin(); - ~ZaMultiCompPlugin() override; protected: // ------------------------------------------------------------------- @@ -100,15 +99,15 @@ protected: // ------------------------------------------------------------------- // Init - void d_initParameter(uint32_t index, Parameter& parameter) ; - void d_initProgramName(uint32_t index, d_string& programName) ; + void d_initParameter(uint32_t index, Parameter& parameter) override; + void d_initProgramName(uint32_t index, d_string& programName) override; // ------------------------------------------------------------------- // Internal data float d_getParameterValue(uint32_t index) const override; void d_setParameterValue(uint32_t index, float value) override; - void d_setProgram(uint32_t index) ; + void d_setProgram(uint32_t index) override; // ------------------------------------------------------------------- // Process @@ -136,8 +135,7 @@ protected: void set_hp_coeffs(float fc, float q, float sr, int i, float gain); void d_activate() override; - void d_deactivate() override; - void d_run(float** inputs, float** outputs, uint32_t frames) override; + void d_run(const float** inputs, float** outputs, uint32_t frames) override; // ------------------------------------------------------------------- @@ -159,7 +157,6 @@ private: float z2[MAX_FILT]; }; - // ----------------------------------------------------------------------- END_NAMESPACE_DISTRHO diff --git a/plugins/ZaMultiComp/ZaMultiCompUI.cpp b/plugins/ZaMultiComp/ZaMultiCompUI.cpp index f8bc5b1..70236af 100644 --- a/plugins/ZaMultiComp/ZaMultiCompUI.cpp +++ b/plugins/ZaMultiComp/ZaMultiCompUI.cpp @@ -1,5 +1,5 @@ /* - * ZaMultiComp mono multiband compressor + * ZaMultiComp mono multiband compressor * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or @@ -15,8 +15,8 @@ * For a full copy of the GNU General Public License see the doc/GPL.txt file. */ +#include "ZaMultiCompPlugin.hpp" #include "ZaMultiCompUI.hpp" -#include <stdio.h> using DGL::Point; @@ -38,23 +38,23 @@ ZaMultiCompUI::ZaMultiCompUI() fLedRedValue1 = 0.0f; fLedRedValue2 = 0.0f; fLedRedValue3 = 0.0f; - fLedYellowValue = 0.0f; + fLedYellowValue = 0.0f; // knob Image knobImage(ZaMultiCompArtwork::knobData, ZaMultiCompArtwork::knobWidth, ZaMultiCompArtwork::knobHeight); - // knob + // knob fKnobAttack = new ImageKnob(this, knobImage); - fKnobAttack->setPos(24, 43); + fKnobAttack->setAbsolutePos(24, 43); fKnobAttack->setRange(0.1f, 200.0f); fKnobAttack->setStep(0.1f); - fKnobAttack->setLogScale(true); + fKnobAttack->setUsingLogScale(true); fKnobAttack->setDefault(10.0f); fKnobAttack->setRotationAngle(240); fKnobAttack->setCallback(this); fKnobRelease = new ImageKnob(this, knobImage); - fKnobRelease->setPos(108, 43); + fKnobRelease->setAbsolutePos(108, 43); fKnobRelease->setRange(50.0f, 500.0f); fKnobRelease->setStep(1.0f); fKnobRelease->setDefault(80.0f); @@ -62,7 +62,7 @@ ZaMultiCompUI::ZaMultiCompUI() fKnobRelease->setCallback(this); fKnobThresh = new ImageKnob(this, knobImage); - fKnobThresh->setPos(191.5, 43); + fKnobThresh->setAbsolutePos(191.5, 43); fKnobThresh->setRange(-60.0f, 0.0f); fKnobThresh->setStep(1.0f); fKnobThresh->setDefault(0.0f); @@ -70,7 +70,7 @@ ZaMultiCompUI::ZaMultiCompUI() fKnobThresh->setCallback(this); fKnobRatio = new ImageKnob(this, knobImage); - fKnobRatio->setPos(270, 43); + fKnobRatio->setAbsolutePos(270, 43); fKnobRatio->setRange(1.0f, 20.0f); fKnobRatio->setStep(0.1f); fKnobRatio->setDefault(4.0f); @@ -78,7 +78,7 @@ ZaMultiCompUI::ZaMultiCompUI() fKnobRatio->setCallback(this); fKnobKnee = new ImageKnob(this, knobImage); - fKnobKnee->setPos(348.5, 43); + fKnobKnee->setAbsolutePos(348.5, 43); fKnobKnee->setRange(0.0f, 8.0f); fKnobKnee->setStep(0.1f); fKnobKnee->setDefault(0.0f); @@ -86,7 +86,7 @@ ZaMultiCompUI::ZaMultiCompUI() fKnobKnee->setCallback(this); fKnobGlobalGain = new ImageKnob(this, knobImage); - fKnobGlobalGain->setPos(427.3, 43); + fKnobGlobalGain->setAbsolutePos(427.3, 43); fKnobGlobalGain->setRange(-30.0f, 30.0f); fKnobGlobalGain->setStep(1.0f); fKnobGlobalGain->setDefault(0.0f); @@ -94,25 +94,25 @@ ZaMultiCompUI::ZaMultiCompUI() fKnobGlobalGain->setCallback(this); fKnobXover2 = new ImageKnob(this, knobImage); - fKnobXover2->setPos(84, 121); + fKnobXover2->setAbsolutePos(84, 121); fKnobXover2->setRange(1400.f, 14000.f); fKnobXover2->setStep(1.0f); - fKnobXover2->setLogScale(true); + fKnobXover2->setUsingLogScale(true); fKnobXover2->setDefault(1400.f); fKnobXover2->setRotationAngle(240); fKnobXover2->setCallback(this); fKnobXover1 = new ImageKnob(this, knobImage); - fKnobXover1->setPos(84, 176); + fKnobXover1->setAbsolutePos(84, 176); fKnobXover1->setRange(20.0f, 1400.0f); fKnobXover1->setStep(1.0f); - fKnobXover1->setLogScale(true); + fKnobXover1->setUsingLogScale(true); fKnobXover1->setDefault(250.0f); fKnobXover1->setRotationAngle(240); fKnobXover1->setCallback(this); fKnobMakeup3 = new ImageKnob(this, knobImage); - fKnobMakeup3->setPos(167.75, 99.5); + fKnobMakeup3->setAbsolutePos(167.75, 99.5); fKnobMakeup3->setRange(0.0f, 30.0f); fKnobMakeup3->setStep(0.1f); fKnobMakeup3->setDefault(0.0f); @@ -120,7 +120,7 @@ ZaMultiCompUI::ZaMultiCompUI() fKnobMakeup3->setCallback(this); fKnobMakeup2 = new ImageKnob(this, knobImage); - fKnobMakeup2->setPos(167.75, 150.25); + fKnobMakeup2->setAbsolutePos(167.75, 150.25); fKnobMakeup2->setRange(0.0f, 30.0f); fKnobMakeup2->setStep(0.1f); fKnobMakeup2->setDefault(0.0f); @@ -128,7 +128,7 @@ ZaMultiCompUI::ZaMultiCompUI() fKnobMakeup2->setCallback(this); fKnobMakeup1 = new ImageKnob(this, knobImage); - fKnobMakeup1->setPos(167.75, 201.4); + fKnobMakeup1->setAbsolutePos(167.75, 201.4); fKnobMakeup1->setRange(0.0f, 30.0f); fKnobMakeup1->setStep(0.1f); fKnobMakeup1->setDefault(0.0f); @@ -142,61 +142,43 @@ ZaMultiCompUI::ZaMultiCompUI() Point<int> togglePosStart(247,109); - fToggleBypass3 = new ImageToggle(this, toggleoffImage, toggleoffImage, toggleonImage); - fToggleBypass3->setPos(togglePosStart); + fToggleBypass3 = new ImageToggle(this, toggleoffImage, toggleonImage); + fToggleBypass3->setAbsolutePos(togglePosStart); fToggleBypass3->setCallback(this); togglePosStart.setY(158); - fToggleBypass2 = new ImageToggle(this, toggleoffImage, toggleoffImage, toggleonImage); - fToggleBypass2->setPos(togglePosStart); + fToggleBypass2 = new ImageToggle(this, toggleoffImage, toggleonImage); + fToggleBypass2->setAbsolutePos(togglePosStart); fToggleBypass2->setCallback(this); togglePosStart.setY(209); - fToggleBypass1 = new ImageToggle(this, toggleoffImage, toggleoffImage, toggleonImage); - fToggleBypass1->setPos(togglePosStart); + fToggleBypass1 = new ImageToggle(this, toggleoffImage, toggleonImage); + fToggleBypass1->setAbsolutePos(togglePosStart); fToggleBypass1->setCallback(this); togglePosStart.setX(278); togglePosStart.setY(113); - fToggleListen3 = new ImageToggle(this, toggleoffhImage, toggleoffhImage, toggleonhImage); - fToggleListen3->setPos(togglePosStart); + fToggleListen3 = new ImageToggle(this, toggleoffhImage, toggleonhImage); + fToggleListen3->setAbsolutePos(togglePosStart); fToggleListen3->setCallback(this); togglePosStart.setY(164); - fToggleListen2 = new ImageToggle(this, toggleoffhImage, toggleoffhImage, toggleonhImage); - fToggleListen2->setPos(togglePosStart); + fToggleListen2 = new ImageToggle(this, toggleoffhImage, toggleonhImage); + fToggleListen2->setAbsolutePos(togglePosStart); fToggleListen2->setCallback(this); togglePosStart.setY(214); - fToggleListen1 = new ImageToggle(this, toggleoffhImage, toggleoffhImage, toggleonhImage); - fToggleListen1->setPos(togglePosStart); + fToggleListen1 = new ImageToggle(this, toggleoffhImage, toggleonhImage); + fToggleListen1->setAbsolutePos(togglePosStart); fToggleListen1->setCallback(this); -} -ZaMultiCompUI::~ZaMultiCompUI() -{ - delete fKnobAttack; - delete fKnobRelease; - delete fKnobThresh; - delete fKnobRatio; - delete fKnobKnee; - delete fKnobGlobalGain; - delete fKnobMakeup1; - delete fKnobMakeup2; - delete fKnobMakeup3; - delete fKnobXover1; - delete fKnobXover2; - delete fToggleBypass1; - delete fToggleBypass2; - delete fToggleBypass3; - delete fToggleListen1; - delete fToggleListen2; - delete fToggleListen3; + // set default values + d_programChanged(0); } // ----------------------------------------------------------------------- @@ -502,13 +484,13 @@ void ZaMultiCompUI::onDisplay() else numRedLeds3 = 0; for (int i=numRedLeds1; i>0; --i) - fLedRedImg.draw(sLedInitialX + (12 - i)*sLedSpacing, sRedLed1StaticY); + fLedRedImg.drawAt(sLedInitialX + (12 - i)*sLedSpacing, sRedLed1StaticY); for (int i=numRedLeds2; i>0; --i) - fLedRedImg.draw(sLedInitialX + (12 - i)*sLedSpacing, sRedLed2StaticY); + fLedRedImg.drawAt(sLedInitialX + (12 - i)*sLedSpacing, sRedLed2StaticY); for (int i=numRedLeds3; i>0; --i) - fLedRedImg.draw(sLedInitialX + (12 - i)*sLedSpacing, sRedLed3StaticY); + fLedRedImg.drawAt(sLedInitialX + (12 - i)*sLedSpacing, sRedLed3StaticY); if (fLedYellowValue >= 20.f) numYellowLeds = 19; @@ -552,12 +534,12 @@ void ZaMultiCompUI::onDisplay() if (numYellowLeds > 12) { for (int i=12; i<numYellowLeds; ++i) - fLedRedImg.draw(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); + fLedRedImg.drawAt(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); for (int i=0; i<12; ++i) - fLedYellowImg.draw(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); + fLedYellowImg.drawAt(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); } else { for (int i=0; i<numYellowLeds; ++i) - fLedYellowImg.draw(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); + fLedYellowImg.drawAt(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); } } diff --git a/plugins/ZaMultiComp/ZaMultiCompUI.hpp b/plugins/ZaMultiComp/ZaMultiCompUI.hpp index 7eac204..3d85b80 100644 --- a/plugins/ZaMultiComp/ZaMultiCompUI.hpp +++ b/plugins/ZaMultiComp/ZaMultiCompUI.hpp @@ -1,6 +1,6 @@ /* * ZaMultiComp mono multiband compressor - * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> + * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -24,7 +24,6 @@ #include "ImageToggle.hpp" #include "ZaMultiCompArtwork.hpp" -#include "ZaMultiCompPlugin.hpp" using DGL::Image; using DGL::ImageKnob; @@ -35,23 +34,22 @@ START_NAMESPACE_DISTRHO // ----------------------------------------------------------------------- class ZaMultiCompUI : public UI, - public ImageKnob::Callback, - public ImageToggle::Callback + public ImageKnob::Callback, + public ImageToggle::Callback { public: ZaMultiCompUI(); - ~ZaMultiCompUI() override; protected: // ------------------------------------------------------------------- // Information - unsigned int d_getWidth() const noexcept override + uint d_getWidth() const noexcept override { return ZaMultiCompArtwork::zamulticompWidth; } - unsigned int d_getHeight() const noexcept override + uint d_getHeight() const noexcept override { return ZaMultiCompArtwork::zamulticompHeight; } @@ -75,23 +73,13 @@ protected: private: Image fImgBackground; - ImageKnob* fKnobAttack; - ImageKnob* fKnobRelease; - ImageKnob* fKnobThresh; - ImageKnob* fKnobRatio; - ImageKnob* fKnobKnee; - ImageKnob* fKnobGlobalGain; - ImageKnob* fKnobMakeup1; - ImageKnob* fKnobMakeup2; - ImageKnob* fKnobMakeup3; - ImageKnob* fKnobXover1; - ImageKnob* fKnobXover2; - ImageToggle* fToggleBypass1; - ImageToggle* fToggleBypass2; - ImageToggle* fToggleBypass3; - ImageToggle* fToggleListen1; - ImageToggle* fToggleListen2; - ImageToggle* fToggleListen3; + + ScopedPointer<ImageKnob> fKnobAttack, fKnobRelease, fKnobThresh; + ScopedPointer<ImageKnob> fKnobRatio, fKnobKnee, fKnobGlobalGain; + ScopedPointer<ImageKnob> fKnobMakeup1, fKnobMakeup2, fKnobMakeup3; + ScopedPointer<ImageKnob> fKnobXover1, fKnobXover2; + ScopedPointer<ImageToggle> fToggleBypass1, fToggleBypass2, fToggleBypass3; + ScopedPointer<ImageToggle> fToggleListen1, fToggleListen2, fToggleListen3; Image fLedRedImg; float fLedRedValue1; diff --git a/plugins/ZaMultiCompX2/Makefile b/plugins/ZaMultiCompX2/Makefile index 0f7c786..60d49b9 100644 --- a/plugins/ZaMultiCompX2/Makefile +++ b/plugins/ZaMultiCompX2/Makefile @@ -20,13 +20,17 @@ OBJS_UI = \ ZaMultiCompX2UI.cpp.o # -------------------------------------------------------------- -# No custom UI for now +# Do some magic -#TARGET_NOUI = true +include ../Makefile.mk # -------------------------------------------------------------- -# Do some magic +# Enable all possible plugin types -include ../Makefile.mk +ifeq ($(LINUX),true) +all: jack ladspa dssi lv2_sep vst +else +all: ladspa dssi lv2_sep vst +endif # -------------------------------------------------------------- diff --git a/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.cpp b/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.cpp index b9ce6d4..f1c645b 100644 --- a/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.cpp +++ b/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.cpp @@ -26,13 +26,6 @@ ZaMultiCompX2Plugin::ZaMultiCompX2Plugin() { // set default values d_setProgram(0); - - // reset - d_deactivate(); -} - -ZaMultiCompX2Plugin::~ZaMultiCompX2Plugin() -{ } // ----------------------------------------------------------------------- @@ -530,12 +523,6 @@ void ZaMultiCompX2Plugin::d_activate() maxL = maxR = 0.f; } -void ZaMultiCompX2Plugin::d_deactivate() -{ - // all values to zero - d_activate(); -} - float ZaMultiCompX2Plugin::run_filter(int i, int ch, float in) { in = sanitize_denormal(in); @@ -568,14 +555,14 @@ void ZaMultiCompX2Plugin::set_lp_coeffs(float fc, float q, float sr, int i, int b2[ch][i] = (float)((1.f - alpha)*inv); } -void ZaMultiCompX2Plugin::set_hp_coeffs(float fc, float q, float sr, int i, int ch, float gain=1.0) -{ +void ZaMultiCompX2Plugin::set_hp_coeffs(float fc, float q, float sr, int i, int ch, float gain=1.0) +{ float omega=(float)(2.f*M_PI*fc/sr); float sn=sin(omega); float cs=cos(omega); float alpha=(float)(sn/(2.f*q)); float inv=(float)(1.f/(1.f+alpha)); - + a0[ch][i] = (float)(gain*inv*(1.f + cs)/2.f); a1[ch][i] = -2.f * a0[ch][i]; a2[ch][i] = a0[ch][i]; @@ -605,9 +592,9 @@ void ZaMultiCompX2Plugin::run_comp(int k, float inL, float inR, float *outL, flo Lxg = (inL==0.f) ? -160.f : to_dB(fabs(inL)); Rxg = (inR==0.f) ? -160.f : to_dB(fabs(inR)); Lxg = sanitize_denormal(Lxg); - Rxg = sanitize_denormal(Rxg); - - + Rxg = sanitize_denormal(Rxg); + + if (2.f*(Lxg-thresdb[k])<-width) { Lyg = Lxg; } else if (2.f*fabs(Lxg-thresdb[k])<=width) { @@ -615,9 +602,9 @@ void ZaMultiCompX2Plugin::run_comp(int k, float inL, float inR, float *outL, flo } else if (2.f*(Lxg-thresdb[k])>width) { Lyg = thresdb[k] + (Lxg-thresdb[k])/ratio; } - - Lyg = sanitize_denormal(Lyg); - + + Lyg = sanitize_denormal(Lyg); + if (2.f*(Rxg-thresdb[k])<-width) { Ryg = Rxg; } else if (2.f*fabs(Rxg-thresdb[k])<=width) { @@ -625,37 +612,37 @@ void ZaMultiCompX2Plugin::run_comp(int k, float inL, float inR, float *outL, flo } else if (2.f*(Rxg-thresdb[k])>width) { Ryg = thresdb[k] + (Rxg-thresdb[k])/ratio; } - - Ryg = sanitize_denormal(Ryg); - + + Ryg = sanitize_denormal(Ryg); + if (stereolink == STEREOLINK_MAX) { Lxl = Rxl = fmaxf(Lxg - Lyg, Rxg - Ryg); } else { Lxl = Rxl = (Lxg - Lyg + Rxg - Ryg) / 2.f; - } - - old_y1[0][k] = sanitize_denormal(old_y1[0][k]); + } + + old_y1[0][k] = sanitize_denormal(old_y1[0][k]); old_y1[1][k] = sanitize_denormal(old_y1[1][k]); - old_yl[0][k] = sanitize_denormal(old_yl[0][k]); + old_yl[0][k] = sanitize_denormal(old_yl[0][k]); old_yl[1][k] = sanitize_denormal(old_yl[1][k]); - - - Ly1 = fmaxf(Lxl, release_coeff * old_y1[0][k]+(1.f-release_coeff)*Lxl); + + + Ly1 = fmaxf(Lxl, release_coeff * old_y1[0][k]+(1.f-release_coeff)*Lxl); Lyl = attack_coeff * old_yl[0][k]+(1.f-attack_coeff)*Ly1; Ly1 = sanitize_denormal(Ly1); Lyl = sanitize_denormal(Lyl); - + cdb = -Lyl; Lgain = from_dB(cdb); - + Ry1 = fmaxf(Rxl, release_coeff * old_y1[1][k]+(1.f-release_coeff)*Rxl); Ryl = attack_coeff * old_yl[1][k]+(1.f-attack_coeff)*Ry1; Ry1 = sanitize_denormal(Ry1); Ryl = sanitize_denormal(Ryl); - + cdb = -Ryl; Rgain = from_dB(cdb); - + if (stereolink == STEREOLINK_MAX) gainr[k] = fmaxf(Lyl, Ryl); else @@ -665,14 +652,14 @@ void ZaMultiCompX2Plugin::run_comp(int k, float inL, float inR, float *outL, flo *outL *= Lgain; *outR = inR; *outR *= Rgain; - + old_yl[0][k] = Lyl; old_yl[1][k] = Ryl; old_y1[0][k] = Ly1; - old_y1[1][k] = Ry1; + old_y1[1][k] = Ry1; } -void ZaMultiCompX2Plugin::d_run(float** inputs, float** outputs, uint32_t frames) +void ZaMultiCompX2Plugin::d_run(const float** inputs, float** outputs, uint32_t frames) { float srate = d_getSampleRate(); float maxxL = maxL; @@ -745,14 +732,14 @@ void ZaMultiCompX2Plugin::d_run(float** inputs, float** outputs, uint32_t frames fil4[1] = run_filter(6, 1, inr); tmp5[0] = run_filter(7, 0, fil4[0]); tmp5[1] = run_filter(7, 1, fil4[1]); - if (tog3) + if (tog3) run_comp(2, tmp5[0], tmp5[1], &outL[2], &outR[2]); tmp6[0] = tog3 ? outL[2] * from_dB(makeup[2]) : tmp5[0]; tmp6[1] = tog3 ? outR[2] * from_dB(makeup[2]) : tmp5[1]; - outputs[0][i] = outputs[1][i] = 0.f; + outputs[0][i] = outputs[1][i] = 0.f; if (listen1) { listenmode = 1; outputs[0][i] += outL[0] * tog1*from_dB(makeup[0]) diff --git a/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.hpp b/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.hpp index 5270206..20a5585 100644 --- a/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.hpp +++ b/plugins/ZaMultiCompX2/ZaMultiCompX2Plugin.hpp @@ -70,7 +70,7 @@ public: paramOutputLevelR, paramCount }; - + enum States { stateReadMeter, @@ -78,8 +78,6 @@ public: }; ZaMultiCompX2Plugin(); - ~ZaMultiCompX2Plugin() override; - protected: // ------------------------------------------------------------------- @@ -151,8 +149,7 @@ protected: void set_hp_coeffs(float fc, float q, float sr, int i, int ch, float gain); void d_activate() override; - void d_deactivate() override; - void d_run(float** inputs, float** outputs, uint32_t frames) override; + void d_run(const float** inputs, float** outputs, uint32_t frames) override; // ------------------------------------------------------------------- diff --git a/plugins/ZaMultiCompX2/ZaMultiCompX2UI.cpp b/plugins/ZaMultiCompX2/ZaMultiCompX2UI.cpp index c0776a6..53cc10e 100644 --- a/plugins/ZaMultiCompX2/ZaMultiCompX2UI.cpp +++ b/plugins/ZaMultiCompX2/ZaMultiCompX2UI.cpp @@ -1,5 +1,5 @@ /* - * ZaMultiCompX2 Stereo multiband compressor + * ZaMultiCompX2 Stereo multiband compressor * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or @@ -15,8 +15,8 @@ * For a full copy of the GNU General Public License see the doc/GPL.txt file. */ +#include "ZaMultiCompX2Plugin.hpp" #include "ZaMultiCompX2UI.hpp" -#include <stdio.h> using DGL::Point; @@ -38,105 +38,105 @@ ZaMultiCompX2UI::ZaMultiCompX2UI() fLedRedValue1 = 0.0f; fLedRedValue2 = 0.0f; fLedRedValue3 = 0.0f; - fLedYellowValueL = 0.0f; - fLedYellowValueR = 0.0f; + fLedYellowValueL = 0.0f; + fLedYellowValueR = 0.0f; // knob Image knobImage(ZaMultiCompX2Artwork::knobData, ZaMultiCompX2Artwork::knobWidth, ZaMultiCompX2Artwork::knobHeight); - // knob + // knob fKnobAttack = new ImageKnob(this, knobImage); - fKnobAttack->setPos(24, 43); + fKnobAttack->setAbsolutePos(24, 43); fKnobAttack->setRange(0.1f, 200.0f); - fKnobAttack->setLogScale(true); + fKnobAttack->setUsingLogScale(true); fKnobAttack->setDefault(10.0f); fKnobAttack->setStep(0.1f); fKnobAttack->setRotationAngle(240); fKnobAttack->setCallback(this); fKnobRelease = new ImageKnob(this, knobImage); - fKnobRelease->setPos(108, 43); + fKnobRelease->setAbsolutePos(108, 43); fKnobRelease->setRange(50.0f, 500.0f); fKnobRelease->setDefault(80.0f); fKnobRelease->setRotationAngle(240); fKnobRelease->setCallback(this); fKnobThresh3 = new ImageKnob(this, knobImage); - fKnobThresh3->setPos(94.5, 99); + fKnobThresh3->setAbsolutePos(94.5, 99); fKnobThresh3->setRange(-60.0f, 0.0f); fKnobThresh3->setDefault(-16.0f); fKnobThresh3->setRotationAngle(240); fKnobThresh3->setCallback(this); fKnobThresh2 = new ImageKnob(this, knobImage); - fKnobThresh2->setPos(94.5, 150); + fKnobThresh2->setAbsolutePos(94.5, 150); fKnobThresh2->setRange(-60.0f, 0.0f); fKnobThresh2->setDefault(-18.0f); fKnobThresh2->setRotationAngle(240); fKnobThresh2->setCallback(this); fKnobThresh1 = new ImageKnob(this, knobImage); - fKnobThresh1->setPos(94.5, 201); + fKnobThresh1->setAbsolutePos(94.5, 201); fKnobThresh1->setRange(-60.0f, 0.0f); fKnobThresh1->setDefault(-20.0f); fKnobThresh1->setRotationAngle(240); fKnobThresh1->setCallback(this); fKnobRatio = new ImageKnob(this, knobImage); - fKnobRatio->setPos(191.5, 43); + fKnobRatio->setAbsolutePos(191.5, 43); fKnobRatio->setRange(1.0f, 20.0f); fKnobRatio->setDefault(4.0f); fKnobRatio->setRotationAngle(240); fKnobRatio->setCallback(this); fKnobKnee = new ImageKnob(this, knobImage); - fKnobKnee->setPos(273, 43); + fKnobKnee->setAbsolutePos(273, 43); fKnobKnee->setRange(0.0f, 8.0f); fKnobKnee->setDefault(0.0f); fKnobKnee->setRotationAngle(240); fKnobKnee->setCallback(this); fKnobGlobalGain = new ImageKnob(this, knobImage); - fKnobGlobalGain->setPos(427.3, 43); + fKnobGlobalGain->setAbsolutePos(427.3, 43); fKnobGlobalGain->setRange(-30.0f, 30.0f); fKnobGlobalGain->setDefault(0.0f); fKnobGlobalGain->setRotationAngle(240); fKnobGlobalGain->setCallback(this); fKnobXover2 = new ImageKnob(this, knobImage); - fKnobXover2->setPos(23, 121); + fKnobXover2->setAbsolutePos(23, 121); fKnobXover2->setRange(1400.f, 14000.f); - fKnobXover2->setLogScale(true); + fKnobXover2->setUsingLogScale(true); fKnobXover2->setDefault(1400.f); fKnobXover2->setStep(5.f); fKnobXover2->setRotationAngle(240); fKnobXover2->setCallback(this); fKnobXover1 = new ImageKnob(this, knobImage); - fKnobXover1->setPos(23, 175.5); + fKnobXover1->setAbsolutePos(23, 175.5); fKnobXover1->setRange(20.0f, 1400.0f); - fKnobXover1->setLogScale(true); + fKnobXover1->setUsingLogScale(true); fKnobXover1->setDefault(250.0f); fKnobXover1->setStep(1.f); fKnobXover1->setRotationAngle(240); fKnobXover1->setCallback(this); fKnobMakeup3 = new ImageKnob(this, knobImage); - fKnobMakeup3->setPos(167.75, 99.5); + fKnobMakeup3->setAbsolutePos(167.75, 99.5); fKnobMakeup3->setRange(0.0f, 30.0f); fKnobMakeup3->setDefault(0.0f); fKnobMakeup3->setRotationAngle(240); fKnobMakeup3->setCallback(this); fKnobMakeup2 = new ImageKnob(this, knobImage); - fKnobMakeup2->setPos(167.75, 150.25); + fKnobMakeup2->setAbsolutePos(167.75, 150.25); fKnobMakeup2->setRange(0.0f, 30.0f); fKnobMakeup2->setDefault(0.0f); fKnobMakeup2->setRotationAngle(240); fKnobMakeup2->setCallback(this); fKnobMakeup1 = new ImageKnob(this, knobImage); - fKnobMakeup1->setPos(167.75, 201.4); + fKnobMakeup1->setAbsolutePos(167.75, 201.4); fKnobMakeup1->setRange(0.0f, 30.0f); fKnobMakeup1->setDefault(0.0f); fKnobMakeup1->setRotationAngle(240); @@ -149,46 +149,46 @@ ZaMultiCompX2UI::ZaMultiCompX2UI() Point<int> togglePosStart(247,108); - fToggleBypass3 = new ImageToggle(this, toggleoffImage, toggleoffImage, toggleonImage); - fToggleBypass3->setPos(togglePosStart); + fToggleBypass3 = new ImageToggle(this, toggleoffImage, toggleonImage); + fToggleBypass3->setAbsolutePos(togglePosStart); fToggleBypass3->setCallback(this); togglePosStart.setY(158); - fToggleBypass2 = new ImageToggle(this, toggleoffImage, toggleoffImage, toggleonImage); - fToggleBypass2->setPos(togglePosStart); + fToggleBypass2 = new ImageToggle(this, toggleoffImage, toggleonImage); + fToggleBypass2->setAbsolutePos(togglePosStart); fToggleBypass2->setCallback(this); togglePosStart.setY(209); - fToggleBypass1 = new ImageToggle(this, toggleoffImage, toggleoffImage, toggleonImage); - fToggleBypass1->setPos(togglePosStart); + fToggleBypass1 = new ImageToggle(this, toggleoffImage, toggleonImage); + fToggleBypass1->setAbsolutePos(togglePosStart); fToggleBypass1->setCallback(this); togglePosStart.setX(278); togglePosStart.setY(113); - fToggleListen3 = new ImageToggle(this, toggleoffhImage, toggleoffhImage, toggleonhImage); - fToggleListen3->setPos(togglePosStart); + fToggleListen3 = new ImageToggle(this, toggleoffhImage, toggleonhImage); + fToggleListen3->setAbsolutePos(togglePosStart); fToggleListen3->setCallback(this); togglePosStart.setY(164); - fToggleListen2 = new ImageToggle(this, toggleoffhImage, toggleoffhImage, toggleonhImage); - fToggleListen2->setPos(togglePosStart); + fToggleListen2 = new ImageToggle(this, toggleoffhImage, toggleonhImage); + fToggleListen2->setAbsolutePos(togglePosStart); fToggleListen2->setCallback(this); togglePosStart.setY(214); - fToggleListen1 = new ImageToggle(this, toggleoffhImage, toggleoffhImage, toggleonhImage); - fToggleListen1->setPos(togglePosStart); + fToggleListen1 = new ImageToggle(this, toggleoffhImage, toggleonhImage); + fToggleListen1->setAbsolutePos(togglePosStart); fToggleListen1->setCallback(this); togglePosStart.setX(285.5); togglePosStart.setY(254); - fToggleStereo = new ImageToggle(this, toggleoffImage, toggleoffImage, toggleonImage); - fToggleStereo->setPos(togglePosStart); + fToggleStereo = new ImageToggle(this, toggleoffImage, toggleonImage); + fToggleStereo->setAbsolutePos(togglePosStart); fToggleStereo->setCallback(this); fCanvasArea.setPos(540, 32); @@ -215,30 +215,8 @@ ZaMultiCompX2UI::ZaMultiCompX2UI() } } -} - -ZaMultiCompX2UI::~ZaMultiCompX2UI() -{ - delete fKnobAttack; - delete fKnobRelease; - delete fKnobThresh1; - delete fKnobThresh2; - delete fKnobThresh3; - delete fKnobRatio; - delete fKnobKnee; - delete fKnobGlobalGain; - delete fKnobMakeup1; - delete fKnobMakeup2; - delete fKnobMakeup3; - delete fKnobXover1; - delete fKnobXover2; - delete fToggleBypass1; - delete fToggleBypass2; - delete fToggleBypass3; - delete fToggleListen1; - delete fToggleListen2; - delete fToggleListen3; - delete fToggleStereo; + // set default values + d_programChanged(0); } void ZaMultiCompX2UI::compcurve(float in, int k, float *outx, float* outy) { @@ -277,16 +255,16 @@ void ZaMultiCompX2UI::calc_compcurves() { compcurve(x2, k, &compx[k][i], &compy[k][i]); compx[k][i] = fCanvasArea.getX() + compx[k][i]*fCanvasArea.getWidth(); compy[k][i] = fCanvasArea.getY() + (1.-compy[k][i])*fCanvasArea.getHeight(); - } + } //dot follows curve: //compcurve(from_dB(-ui->gainred), k, &dotx[0], &doty[0]); //dotx[0] = -(1-dotx[0])*280. + 280.; - //doty[0] = (1.-doty[0])*280.; - + //doty[0] = (1.-doty[0])*280.; + //dot follows centre: //dotx[0] = -(1.- from_dB(-gainred))*280. + 280.; //doty[0] = (1.- from_dB(-gainred))*280.; - + //printf("gainr=%.2f x=%.2f y=%.2f\n",ui->gainred, ui->dotx[0], ui->doty[0]); } } @@ -692,13 +670,13 @@ void ZaMultiCompX2UI::onDisplay() else numRedLeds3 = 0; for (int i=numRedLeds1; i>0; --i) - fLedRedImg.draw(sLedInitialX + (12 - i)*sLedSpacing, sRedLed1StaticY); + fLedRedImg.drawAt(sLedInitialX + (12 - i)*sLedSpacing, sRedLed1StaticY); for (int i=numRedLeds2; i>0; --i) - fLedRedImg.draw(sLedInitialX + (12 - i)*sLedSpacing, sRedLed2StaticY); + fLedRedImg.drawAt(sLedInitialX + (12 - i)*sLedSpacing, sRedLed2StaticY); for (int i=numRedLeds3; i>0; --i) - fLedRedImg.draw(sLedInitialX + (12 - i)*sLedSpacing, sRedLed3StaticY); + fLedRedImg.drawAt(sLedInitialX + (12 - i)*sLedSpacing, sRedLed3StaticY); if (fLedYellowValueL >= 20.f) numYellowLedsL = 19; @@ -742,14 +720,14 @@ void ZaMultiCompX2UI::onDisplay() if (numYellowLedsL > 12) { for (int i=12; i<numYellowLedsL; ++i) - fLedRedImg.draw(sLedInitialX + i*sLedSpacing, sYellowLedStaticYL); + fLedRedImg.drawAt(sLedInitialX + i*sLedSpacing, sYellowLedStaticYL); for (int i=0; i<12; ++i) - fLedYellowImg.draw(sLedInitialX + i*sLedSpacing, sYellowLedStaticYL); + fLedYellowImg.drawAt(sLedInitialX + i*sLedSpacing, sYellowLedStaticYL); } else { for (int i=0; i<numYellowLedsL; ++i) - fLedYellowImg.draw(sLedInitialX + i*sLedSpacing, sYellowLedStaticYL); + fLedYellowImg.drawAt(sLedInitialX + i*sLedSpacing, sYellowLedStaticYL); } - + if (fLedYellowValueR >= 20.f) numYellowLedsR = 19; else if (fLedYellowValueR >= 10.f) @@ -792,12 +770,12 @@ void ZaMultiCompX2UI::onDisplay() if (numYellowLedsR > 12) { for (int i=12; i<numYellowLedsR; ++i) - fLedRedImg.draw(sLedInitialX + i*sLedSpacing, sYellowLedStaticYR); + fLedRedImg.drawAt(sLedInitialX + i*sLedSpacing, sYellowLedStaticYR); for (int i=0; i<12; ++i) - fLedYellowImg.draw(sLedInitialX + i*sLedSpacing, sYellowLedStaticYR); + fLedYellowImg.drawAt(sLedInitialX + i*sLedSpacing, sYellowLedStaticYR); } else { for (int i=0; i<numYellowLedsR; ++i) - fLedYellowImg.draw(sLedInitialX + i*sLedSpacing, sYellowLedStaticYR); + fLedYellowImg.drawAt(sLedInitialX + i*sLedSpacing, sYellowLedStaticYR); } /* // TESTING - remove later diff --git a/plugins/ZaMultiCompX2/ZaMultiCompX2UI.hpp b/plugins/ZaMultiCompX2/ZaMultiCompX2UI.hpp index 67ffcb1..44dcb19 100644 --- a/plugins/ZaMultiCompX2/ZaMultiCompX2UI.hpp +++ b/plugins/ZaMultiCompX2/ZaMultiCompX2UI.hpp @@ -1,5 +1,5 @@ /* - * ZaMultiCompX2 stereo multiband compressor + * ZaMultiCompX2 stereo multiband compressor * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or @@ -20,14 +20,13 @@ #include "DistrhoUI.hpp" -#include "Geometry.hpp" #include "ImageKnob.hpp" #include "ImageToggle.hpp" +#include "ZaMultiCompX2Artwork.hpp" + #define COMPOINTS 1000 #define MAX_COMP 3 -#include "ZaMultiCompX2Artwork.hpp" -#include "ZaMultiCompX2Plugin.hpp" using DGL::Image; using DGL::ImageKnob; @@ -38,23 +37,22 @@ START_NAMESPACE_DISTRHO // ----------------------------------------------------------------------- class ZaMultiCompX2UI : public UI, - public ImageKnob::Callback, - public ImageToggle::Callback + public ImageKnob::Callback, + public ImageToggle::Callback { public: ZaMultiCompX2UI(); - ~ZaMultiCompX2UI() override; protected: // ------------------------------------------------------------------- // Information - unsigned int d_getWidth() const noexcept override + uint d_getWidth() const noexcept override { return ZaMultiCompX2Artwork::zamulticompx2Width; } - unsigned int d_getHeight() const noexcept override + uint d_getHeight() const noexcept override { return ZaMultiCompX2Artwork::zamulticompx2Height; } @@ -100,26 +98,14 @@ sanitize_denormal(double value) { private: Image fImgBackground; - ImageKnob* fKnobAttack; - ImageKnob* fKnobRelease; - ImageKnob* fKnobThresh1; - ImageKnob* fKnobThresh2; - ImageKnob* fKnobThresh3; - ImageKnob* fKnobRatio; - ImageKnob* fKnobKnee; - ImageKnob* fKnobGlobalGain; - ImageKnob* fKnobMakeup1; - ImageKnob* fKnobMakeup2; - ImageKnob* fKnobMakeup3; - ImageKnob* fKnobXover1; - ImageKnob* fKnobXover2; - ImageToggle* fToggleBypass1; - ImageToggle* fToggleBypass2; - ImageToggle* fToggleBypass3; - ImageToggle* fToggleListen1; - ImageToggle* fToggleListen2; - ImageToggle* fToggleListen3; - ImageToggle* fToggleStereo; + ScopedPointer<ImageKnob> fKnobAttack, fKnobRelease; + ScopedPointer<ImageKnob> fKnobThresh1, fKnobThresh2, fKnobThresh3; + ScopedPointer<ImageKnob> fKnobRatio, fKnobKnee, fKnobGlobalGain; + ScopedPointer<ImageKnob> fKnobMakeup1, fKnobMakeup2, fKnobMakeup3; + ScopedPointer<ImageKnob> fKnobXover1, fKnobXover2; + ScopedPointer<ImageToggle> fToggleBypass1, fToggleBypass2, fToggleBypass3; + ScopedPointer<ImageToggle> fToggleListen1, fToggleListen2, fToggleListen3; + ScopedPointer<ImageToggle> fToggleStereo; Image fLedRedImg; float fLedRedValue1; diff --git a/plugins/ZamAutoSat/DistrhoPluginInfo.h b/plugins/ZamAutoSat/DistrhoPluginInfo.h index efa7e32..d5c0cc7 100644 --- a/plugins/ZamAutoSat/DistrhoPluginInfo.h +++ b/plugins/ZamAutoSat/DistrhoPluginInfo.h @@ -27,7 +27,7 @@ #define DISTRHO_PLUGIN_NUM_OUTPUTS 1 #define DISTRHO_PLUGIN_WANT_LATENCY 0 -#define DISTRHO_PLUGIN_WANT_PROGRAMS 1 +#define DISTRHO_PLUGIN_WANT_PROGRAMS 0 #define DISTRHO_PLUGIN_WANT_STATE 0 #define DISTRHO_PLUGIN_WANT_TIMEPOS 0 diff --git a/plugins/ZamAutoSat/Makefile b/plugins/ZamAutoSat/Makefile index 1b114d3..e99ef0e 100644 --- a/plugins/ZamAutoSat/Makefile +++ b/plugins/ZamAutoSat/Makefile @@ -15,18 +15,22 @@ NAME = ZamAutoSat OBJS_DSP = \ ZamAutoSatPlugin.cpp.o -OBJS_UI = \ +OBJS_UI = \ ZamAutoSatArtwork.cpp.o \ ZamAutoSatUI.cpp.o # -------------------------------------------------------------- -# No custom UI for now +# Do some magic -#TARGET_NOUI = true +include ../Makefile.mk # -------------------------------------------------------------- -# Do some magic +# Enable all possible plugin types -include ../Makefile.mk +ifeq ($(LINUX),true) +all: jack ladspa dssi lv2_sep vst +else +all: ladspa dssi lv2_sep vst +endif # -------------------------------------------------------------- diff --git a/plugins/ZamAutoSat/ZamAutoSatPlugin.cpp b/plugins/ZamAutoSat/ZamAutoSatPlugin.cpp index 75e2052..d617d07 100644 --- a/plugins/ZamAutoSat/ZamAutoSatPlugin.cpp +++ b/plugins/ZamAutoSat/ZamAutoSatPlugin.cpp @@ -81,7 +81,7 @@ void ZamAutoSatPlugin::d_deactivate() { } -void ZamAutoSatPlugin::d_run(float** inputs, float** outputs, uint32_t frames) +void ZamAutoSatPlugin::d_run(const float** inputs, float** outputs, uint32_t frames) { uint32_t i; for (i = 0; i < frames; i++) { diff --git a/plugins/ZamAutoSat/ZamAutoSatPlugin.hpp b/plugins/ZamAutoSat/ZamAutoSatPlugin.hpp index 4b722ee..60b16c9 100644 --- a/plugins/ZamAutoSat/ZamAutoSatPlugin.hpp +++ b/plugins/ZamAutoSat/ZamAutoSatPlugin.hpp @@ -73,14 +73,14 @@ protected: // -------------------------------------------------------------------
// Internal data
- float d_getParameterValue(uint32_t index) const override;
- void d_setParameterValue(uint32_t index, float value) override;
+ float d_getParameterValue(uint32_t index) const ;
+ void d_setParameterValue(uint32_t index, float value) ;
void d_setProgram(uint32_t index) ;
// -------------------------------------------------------------------
- void d_activate() override;
- void d_deactivate() override;
- void d_run(float** inputs, float** outputs, uint32_t frames) override;
+ void d_activate() ;
+ void d_deactivate() ;
+ void d_run(const float** inputs, float** outputs, uint32_t frames) override;
// -------------------------------------------------------------------
diff --git a/plugins/ZamAutoSat/ZamAutoSatUI.hpp b/plugins/ZamAutoSat/ZamAutoSatUI.hpp index 921cf26..4875382 100644 --- a/plugins/ZamAutoSat/ZamAutoSatUI.hpp +++ b/plugins/ZamAutoSat/ZamAutoSatUI.hpp @@ -55,7 +55,7 @@ protected: // DSP Callbacks void d_parameterChanged(uint32_t index, float value) override; - void d_programChanged(uint32_t index) override; + void d_programChanged(uint32_t index) ; // ------------------------------------------------------------------- diff --git a/plugins/ZamComp/Makefile b/plugins/ZamComp/Makefile index 12ab20a..16fa761 100644 --- a/plugins/ZamComp/Makefile +++ b/plugins/ZamComp/Makefile @@ -20,13 +20,17 @@ OBJS_UI = \ ZamCompUI.cpp.o # -------------------------------------------------------------- -# No custom UI for now +# Do some magic -#TARGET_NOUI = true +include ../Makefile.mk # -------------------------------------------------------------- -# Do some magic +# Enable all possible plugin types -include ../Makefile.mk +ifeq ($(LINUX),true) +all: jack ladspa dssi lv2_sep vst +else +all: ladspa dssi lv2_sep vst +endif # -------------------------------------------------------------- diff --git a/plugins/ZamComp/ZamCompPlugin.cpp b/plugins/ZamComp/ZamCompPlugin.cpp index 9c5ec34..0b13b5a 100644 --- a/plugins/ZamComp/ZamCompPlugin.cpp +++ b/plugins/ZamComp/ZamCompPlugin.cpp @@ -26,13 +26,6 @@ ZamCompPlugin::ZamCompPlugin() { // set default values d_setProgram(0); - - // reset - d_deactivate(); -} - -ZamCompPlugin::~ZamCompPlugin() -{ } // ----------------------------------------------------------------------- @@ -204,10 +197,6 @@ void ZamCompPlugin::d_setProgram(uint32_t index) ratio = 4.0f; thresdb = 0.0f; makeup = 0.0f; - gainr = 0.0f; - outlevel = -45.f; - - /* Default variable values */ /* reset filter values */ d_activate(); @@ -218,14 +207,12 @@ void ZamCompPlugin::d_setProgram(uint32_t index) void ZamCompPlugin::d_activate() { + gainr = 0.0f; + outlevel = -45.f; + old_yl = old_y1 = 0.0f; } -void ZamCompPlugin::d_deactivate() -{ - // all values to zero -} - -void ZamCompPlugin::d_run(float** inputs, float** outputs, uint32_t frames) +void ZamCompPlugin::d_run(const float** inputs, float** outputs, uint32_t frames) { float srate = d_getSampleRate(); float width=(knee-0.99f)*6.f; @@ -261,7 +248,7 @@ void ZamCompPlugin::d_run(float** inputs, float** outputs, uint32_t frames) yl = attack_coeff * old_yl+(1.f-attack_coeff)*y1; y1 = sanitize_denormal(y1); yl = sanitize_denormal(yl); - + cdb = -yl; gain = from_dB(cdb); @@ -269,7 +256,7 @@ void ZamCompPlugin::d_run(float** inputs, float** outputs, uint32_t frames) outputs[0][i] = inputs[0][i]; outputs[0][i] *= gain * from_dB(makeup); - + max = (fabsf(outputs[0][i]) > max) ? fabsf(outputs[0][i]) : sanitize_denormal(max); old_yl = yl; diff --git a/plugins/ZamComp/ZamCompPlugin.hpp b/plugins/ZamComp/ZamCompPlugin.hpp index 47b148a..ea521a2 100644 --- a/plugins/ZamComp/ZamCompPlugin.hpp +++ b/plugins/ZamComp/ZamCompPlugin.hpp @@ -1,5 +1,5 @@ /*
- * ZamComp mono compressor
+ * ZamComp mono compressor
* Copyright (C) 2014 Damien Zammit <damien@zamaudio.com>
*
* This program is free software; you can redistribute it and/or
@@ -41,7 +41,6 @@ public: };
ZamCompPlugin();
- ~ZamCompPlugin() override;
protected:
// -------------------------------------------------------------------
@@ -75,15 +74,15 @@ protected: // -------------------------------------------------------------------
// Init
- void d_initParameter(uint32_t index, Parameter& parameter) ;
- void d_initProgramName(uint32_t index, d_string& programName) ;
+ void d_initParameter(uint32_t index, Parameter& parameter) override;
+ void d_initProgramName(uint32_t index, d_string& programName) override;
// -------------------------------------------------------------------
// Internal data
float d_getParameterValue(uint32_t index) const override;
void d_setParameterValue(uint32_t index, float value) override;
- void d_setProgram(uint32_t index) ;
+ void d_setProgram(uint32_t index) override;
// -------------------------------------------------------------------
// Process
@@ -106,8 +105,7 @@ protected: }
void d_activate() override;
- void d_deactivate() override;
- void d_run(float** inputs, float** outputs, uint32_t frames) override;
+ void d_run(const float** inputs, float** outputs, uint32_t frames) override;
// -------------------------------------------------------------------
diff --git a/plugins/ZamComp/ZamCompUI.cpp b/plugins/ZamComp/ZamCompUI.cpp index 8a6f0a9..48b4921 100644 --- a/plugins/ZamComp/ZamCompUI.cpp +++ b/plugins/ZamComp/ZamCompUI.cpp @@ -1,6 +1,6 @@ /* * ZamComp mono compressor - * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> + * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -15,10 +15,9 @@ * For a full copy of the GNU General Public License see the doc/GPL.txt file. */ +#include "ZamCompPlugin.hpp" #include "ZamCompUI.hpp" -using DGL::Point; - START_NAMESPACE_DISTRHO // ----------------------------------------------------------------------- @@ -35,23 +34,25 @@ ZamCompUI::ZamCompUI() // led values fLedRedValue = 0.0f; - fLedYellowValue = 0.0f; + fLedYellowValue = 0.0f; // knob Image knobImage(ZamCompArtwork::knobData, ZamCompArtwork::knobWidth, ZamCompArtwork::knobHeight); - // knob + // knob fKnobAttack = new ImageKnob(this, knobImage); - fKnobAttack->setPos(24, 45); + fKnobAttack->setAbsolutePos(24, 45); + fKnobAttack->setId(ZamCompPlugin::paramAttack); fKnobAttack->setRange(0.1f, 200.0f); fKnobAttack->setStep(0.1f); - fKnobAttack->setLogScale(true); + fKnobAttack->setUsingLogScale(true); fKnobAttack->setDefault(10.0f); fKnobAttack->setRotationAngle(240); fKnobAttack->setCallback(this); fKnobRelease = new ImageKnob(this, knobImage); - fKnobRelease->setPos(108, 45); + fKnobRelease->setAbsolutePos(108, 45); + fKnobRelease->setId(ZamCompPlugin::paramRelease); fKnobRelease->setRange(50.0f, 500.0f); fKnobRelease->setStep(1.0f); fKnobRelease->setDefault(80.0f); @@ -59,7 +60,8 @@ ZamCompUI::ZamCompUI() fKnobRelease->setCallback(this); fKnobThresh = new ImageKnob(this, knobImage); - fKnobThresh->setPos(191.5, 45); + fKnobThresh->setAbsolutePos(191.5, 45); + fKnobThresh->setId(ZamCompPlugin::paramThresh); fKnobThresh->setRange(-60.0f, 0.0f); fKnobThresh->setStep(1.0f); fKnobThresh->setDefault(0.0f); @@ -67,7 +69,8 @@ ZamCompUI::ZamCompUI() fKnobThresh->setCallback(this); fKnobRatio = new ImageKnob(this, knobImage); - fKnobRatio->setPos(270, 45); + fKnobRatio->setAbsolutePos(270, 45); + fKnobRatio->setId(ZamCompPlugin::paramRatio); fKnobRatio->setRange(1.0f, 20.0f); fKnobRatio->setStep(0.1f); fKnobRatio->setDefault(4.0f); @@ -75,7 +78,8 @@ ZamCompUI::ZamCompUI() fKnobRatio->setCallback(this); fKnobKnee = new ImageKnob(this, knobImage); - fKnobKnee->setPos(348.5, 45); + fKnobKnee->setAbsolutePos(348.5, 45); + fKnobKnee->setId(ZamCompPlugin::paramKnee); fKnobKnee->setRange(0.0f, 8.0f); fKnobKnee->setStep(0.1f); fKnobKnee->setDefault(0.0f); @@ -83,22 +87,16 @@ ZamCompUI::ZamCompUI() fKnobKnee->setCallback(this); fKnobMakeup = new ImageKnob(this, knobImage); - fKnobMakeup->setPos(427.3, 45); + fKnobMakeup->setAbsolutePos(427.3, 45); + fKnobMakeup->setId(ZamCompPlugin::paramMakeup); fKnobMakeup->setRange(-30.0f, 30.0f); fKnobMakeup->setStep(1.0f); fKnobMakeup->setDefault(0.0f); fKnobMakeup->setRotationAngle(240); fKnobMakeup->setCallback(this); -} -ZamCompUI::~ZamCompUI() -{ - delete fKnobAttack; - delete fKnobRelease; - delete fKnobThresh; - delete fKnobRatio; - delete fKnobKnee; - delete fKnobMakeup; + // set default values + d_programChanged(0); } // ----------------------------------------------------------------------- @@ -148,14 +146,13 @@ void ZamCompUI::d_programChanged(uint32_t index) if (index != 0) return; - /* Default values - fKnobAttack->setDefault(10.0f); - fKnobRelease->setDefault(80.0f); - fKnobThresh->setDefault(0.0f); - fKnobRatio->setDefault(4.0f); - fKnobKnee->setDefault(0.0f); - fKnobMakeup->setDefault(0.0f); - */ + // Default values + fKnobAttack->setValue(10.0f); + fKnobRelease->setValue(80.0f); + fKnobThresh->setValue(0.0f); + fKnobRatio->setValue(4.0f); + fKnobKnee->setValue(0.0f); + fKnobMakeup->setValue(0.0f); } // ----------------------------------------------------------------------- @@ -163,50 +160,17 @@ void ZamCompUI::d_programChanged(uint32_t index) void ZamCompUI::imageKnobDragStarted(ImageKnob* knob) { - if (knob == fKnobAttack) - d_editParameter(ZamCompPlugin::paramAttack, true); - else if (knob == fKnobRelease) - d_editParameter(ZamCompPlugin::paramRelease, true); - else if (knob == fKnobThresh) - d_editParameter(ZamCompPlugin::paramThresh, true); - else if (knob == fKnobRatio) - d_editParameter(ZamCompPlugin::paramRatio, true); - else if (knob == fKnobKnee) - d_editParameter(ZamCompPlugin::paramKnee, true); - else if (knob == fKnobMakeup) - d_editParameter(ZamCompPlugin::paramMakeup, true); + d_editParameter(knob->getId(), true); } void ZamCompUI::imageKnobDragFinished(ImageKnob* knob) { - if (knob == fKnobAttack) - d_editParameter(ZamCompPlugin::paramAttack, false); - else if (knob == fKnobRelease) - d_editParameter(ZamCompPlugin::paramRelease, false); - else if (knob == fKnobThresh) - d_editParameter(ZamCompPlugin::paramThresh, false); - else if (knob == fKnobRatio) - d_editParameter(ZamCompPlugin::paramRatio, false); - else if (knob == fKnobKnee) - d_editParameter(ZamCompPlugin::paramKnee, false); - else if (knob == fKnobMakeup) - d_editParameter(ZamCompPlugin::paramMakeup, false); + d_editParameter(knob->getId(), false); } void ZamCompUI::imageKnobValueChanged(ImageKnob* knob, float value) { - if (knob == fKnobAttack) - d_setParameterValue(ZamCompPlugin::paramAttack, value); - else if (knob == fKnobRelease) - d_setParameterValue(ZamCompPlugin::paramRelease, value); - else if (knob == fKnobThresh) - d_setParameterValue(ZamCompPlugin::paramThresh, value); - else if (knob == fKnobRatio) - d_setParameterValue(ZamCompPlugin::paramRatio, value); - else if (knob == fKnobKnee) - d_setParameterValue(ZamCompPlugin::paramKnee, value); - else if (knob == fKnobMakeup) - d_setParameterValue(ZamCompPlugin::paramMakeup, value); + d_setParameterValue(knob->getId(), value); } void ZamCompUI::onDisplay() @@ -250,7 +214,7 @@ void ZamCompUI::onDisplay() else numRedLeds = 0; for (int i=numRedLeds; i>0; --i) - fLedRedImg.draw(sLedInitialX + (12 - i)*sLedSpacing, sRedLedStaticY); + fLedRedImg.drawAt(sLedInitialX + (12 - i)*sLedSpacing, sRedLedStaticY); if (fLedYellowValue >= 20.f) numYellowLeds = 19; @@ -294,12 +258,12 @@ void ZamCompUI::onDisplay() if (numYellowLeds > 12) { for (int i=12; i<numYellowLeds; ++i) - fLedRedImg.draw(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); + fLedRedImg.drawAt(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); for (int i=0; i<12; ++i) - fLedYellowImg.draw(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); + fLedYellowImg.drawAt(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); } else { for (int i=0; i<numYellowLeds; ++i) - fLedYellowImg.draw(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); + fLedYellowImg.drawAt(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); } } diff --git a/plugins/ZamComp/ZamCompUI.hpp b/plugins/ZamComp/ZamCompUI.hpp index e5faa14..a9e7f75 100644 --- a/plugins/ZamComp/ZamCompUI.hpp +++ b/plugins/ZamComp/ZamCompUI.hpp @@ -1,6 +1,6 @@ /* * ZamComp mono compressor - * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> + * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -23,7 +23,6 @@ #include "ImageKnob.hpp" #include "ZamCompArtwork.hpp" -#include "ZamCompPlugin.hpp" using DGL::Image; using DGL::ImageKnob; @@ -37,18 +36,17 @@ class ZamCompUI : public UI, { public: ZamCompUI(); - ~ZamCompUI() override; protected: // ------------------------------------------------------------------- // Information - unsigned int d_getWidth() const noexcept override + uint d_getWidth() const noexcept override { return ZamCompArtwork::zamcompWidth; } - unsigned int d_getHeight() const noexcept override + uint d_getHeight() const noexcept override { return ZamCompArtwork::zamcompHeight; } @@ -70,12 +68,8 @@ protected: private: Image fImgBackground; - ImageKnob* fKnobAttack; - ImageKnob* fKnobRelease; - ImageKnob* fKnobThresh; - ImageKnob* fKnobRatio; - ImageKnob* fKnobKnee; - ImageKnob* fKnobMakeup; + ScopedPointer<ImageKnob> fKnobAttack, fKnobRelease, fKnobThresh; + ScopedPointer<ImageKnob> fKnobRatio, fKnobKnee, fKnobMakeup; Image fLedRedImg; float fLedRedValue; diff --git a/plugins/ZamCompX2/Makefile b/plugins/ZamCompX2/Makefile index f68deaf..30f8647 100644 --- a/plugins/ZamCompX2/Makefile +++ b/plugins/ZamCompX2/Makefile @@ -20,13 +20,17 @@ OBJS_UI = \ ZamCompX2UI.cpp.o # -------------------------------------------------------------- -# No custom UI for now +# Do some magic -#TARGET_NOUI = true +include ../Makefile.mk # -------------------------------------------------------------- -# Do some magic +# Enable all possible plugin types -include ../Makefile.mk +ifeq ($(LINUX),true) +all: jack ladspa dssi lv2_sep vst +else +all: ladspa dssi lv2_sep vst +endif # -------------------------------------------------------------- diff --git a/plugins/ZamCompX2/ZamCompX2Plugin.cpp b/plugins/ZamCompX2/ZamCompX2Plugin.cpp index 951e095..5165c98 100644 --- a/plugins/ZamCompX2/ZamCompX2Plugin.cpp +++ b/plugins/ZamCompX2/ZamCompX2Plugin.cpp @@ -26,13 +26,6 @@ ZamCompX2Plugin::ZamCompX2Plugin() { // set default values d_setProgram(0); - - // reset - d_deactivate(); -} - -ZamCompX2Plugin::~ZamCompX2Plugin() -{ } // ----------------------------------------------------------------------- @@ -219,11 +212,7 @@ void ZamCompX2Plugin::d_setProgram(uint32_t index) ratio = 4.0f; thresdb = 0.0f; makeup = 0.0f; - gainred = 0.0f; stereolink = 1.0f; - outlevel = -45.0f; - - /* Default variable values */ /* reset filter values */ d_activate(); @@ -234,15 +223,12 @@ void ZamCompX2Plugin::d_setProgram(uint32_t index) void ZamCompX2Plugin::d_activate() { - oldL_yl = oldL_y1 = oldR_yl = oldR_y1 = 0.f; -} - -void ZamCompX2Plugin::d_deactivate() -{ - // all values to zero + gainred = 0.0f; + outlevel = -45.0f; + oldL_yl = oldL_y1 = oldR_yl = oldR_y1 = 0.f; } -void ZamCompX2Plugin::d_run(float** inputs, float** outputs, uint32_t frames) +void ZamCompX2Plugin::d_run(const float** inputs, float** outputs, uint32_t frames) { float srate = d_getSampleRate(); float width=(knee-0.99f)*6.f; @@ -321,7 +307,7 @@ void ZamCompX2Plugin::d_run(float** inputs, float** outputs, uint32_t frames) outputs[0][i] *= Lgain * from_dB(makeup); outputs[1][i] = inputs[1][i]; outputs[1][i] *= Rgain * from_dB(makeup); - + max = (fabsf(outputs[0][i]) > max) ? fabsf(outputs[0][i]) : sanitize_denormal(max); max = (fabsf(outputs[1][i]) > max) ? fabsf(outputs[1][i]) : sanitize_denormal(max); diff --git a/plugins/ZamCompX2/ZamCompX2Plugin.hpp b/plugins/ZamCompX2/ZamCompX2Plugin.hpp index e18bcec..ba8c21d 100644 --- a/plugins/ZamCompX2/ZamCompX2Plugin.hpp +++ b/plugins/ZamCompX2/ZamCompX2Plugin.hpp @@ -46,7 +46,6 @@ public: }; ZamCompX2Plugin(); - ~ZamCompX2Plugin() override; protected: // ------------------------------------------------------------------- @@ -80,15 +79,15 @@ protected: // ------------------------------------------------------------------- // Init - void d_initParameter(uint32_t index, Parameter& parameter) ; - void d_initProgramName(uint32_t index, d_string& programName) ; + void d_initParameter(uint32_t index, Parameter& parameter) override; + void d_initProgramName(uint32_t index, d_string& programName) override; // ------------------------------------------------------------------- // Internal data float d_getParameterValue(uint32_t index) const override; void d_setParameterValue(uint32_t index, float value) override; - void d_setProgram(uint32_t index) ; + void d_setProgram(uint32_t index) override; // ------------------------------------------------------------------- // Process @@ -111,8 +110,7 @@ protected: } void d_activate() override; - void d_deactivate() override; - void d_run(float** inputs, float** outputs, uint32_t frames) override; + void d_run(const float** inputs, float** outputs, uint32_t frames) override; // ------------------------------------------------------------------- diff --git a/plugins/ZamCompX2/ZamCompX2UI.cpp b/plugins/ZamCompX2/ZamCompX2UI.cpp index 02538f3..017f2d7 100644 --- a/plugins/ZamCompX2/ZamCompX2UI.cpp +++ b/plugins/ZamCompX2/ZamCompX2UI.cpp @@ -1,5 +1,5 @@ /* - * ZamCompX2 Stereo compressor + * ZamCompX2 Stereo compressor * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or @@ -15,6 +15,7 @@ * For a full copy of the GNU General Public License see the doc/GPL.txt file. */ +#include "ZamCompX2Plugin.hpp" #include "ZamCompX2UI.hpp" using DGL::Point; @@ -35,23 +36,25 @@ ZamCompX2UI::ZamCompX2UI() // led values fLedRedValue = 0.0f; - fLedYellowValue = 0.0f; + fLedYellowValue = 0.0f; // knob Image knobImage(ZamCompX2Artwork::knobData, ZamCompX2Artwork::knobWidth, ZamCompX2Artwork::knobHeight); - // knob + // knob fKnobAttack = new ImageKnob(this, knobImage); - fKnobAttack->setPos(24, 45); + fKnobAttack->setAbsolutePos(24, 45); + fKnobAttack->setId(ZamCompX2Plugin::paramAttack); fKnobAttack->setRange(0.1f, 200.0f); fKnobAttack->setStep(0.1f); - fKnobAttack->setLogScale(true); + fKnobAttack->setUsingLogScale(true); fKnobAttack->setDefault(10.0f); fKnobAttack->setRotationAngle(240); fKnobAttack->setCallback(this); fKnobRelease = new ImageKnob(this, knobImage); - fKnobRelease->setPos(108, 45); + fKnobRelease->setAbsolutePos(108, 45); + fKnobRelease->setId(ZamCompX2Plugin::paramRelease); fKnobRelease->setRange(50.0f, 500.0f); fKnobRelease->setStep(1.0f); fKnobRelease->setDefault(80.0f); @@ -59,7 +62,8 @@ ZamCompX2UI::ZamCompX2UI() fKnobRelease->setCallback(this); fKnobThresh = new ImageKnob(this, knobImage); - fKnobThresh->setPos(191.5, 45); + fKnobThresh->setAbsolutePos(191.5, 45); + fKnobThresh->setId(ZamCompX2Plugin::paramThresh); fKnobThresh->setRange(-60.0f, 0.0f); fKnobThresh->setStep(1.0f); fKnobThresh->setDefault(0.0f); @@ -67,7 +71,8 @@ ZamCompX2UI::ZamCompX2UI() fKnobThresh->setCallback(this); fKnobRatio = new ImageKnob(this, knobImage); - fKnobRatio->setPos(270, 45); + fKnobRatio->setAbsolutePos(270, 45); + fKnobRatio->setId(ZamCompX2Plugin::paramRatio); fKnobRatio->setRange(1.0f, 20.0f); fKnobRatio->setStep(0.1f); fKnobRatio->setDefault(4.0f); @@ -75,7 +80,8 @@ ZamCompX2UI::ZamCompX2UI() fKnobRatio->setCallback(this); fKnobKnee = new ImageKnob(this, knobImage); - fKnobKnee->setPos(348.5, 45); + fKnobKnee->setAbsolutePos(348.5, 45); + fKnobKnee->setId(ZamCompX2Plugin::paramKnee); fKnobKnee->setRange(0.0f, 8.0f); fKnobKnee->setStep(0.1f); fKnobKnee->setDefault(0.0f); @@ -83,7 +89,8 @@ ZamCompX2UI::ZamCompX2UI() fKnobKnee->setCallback(this); fKnobMakeup = new ImageKnob(this, knobImage); - fKnobMakeup->setPos(427.3, 45); + fKnobMakeup->setAbsolutePos(427.3, 45); + fKnobMakeup->setId(ZamCompX2Plugin::paramMakeup); fKnobMakeup->setRange(-30.0f, 30.0f); fKnobMakeup->setStep(1.0f); fKnobMakeup->setDefault(0.0f); @@ -93,23 +100,13 @@ ZamCompX2UI::ZamCompX2UI() Image toggleonImage(ZamCompX2Artwork::toggleonData, ZamCompX2Artwork::toggleonWidth, ZamCompX2Artwork::toggleonHeight); Image toggleoffImage(ZamCompX2Artwork::toggleoffData, ZamCompX2Artwork::toggleoffWidth, ZamCompX2Artwork::toggleoffHeight); - Point<int> togglePosStart(652,72); - - fToggleStereo = new ImageToggle(this, toggleoffImage, toggleoffImage, toggleonImage); - fToggleStereo->setPos(togglePosStart); + fToggleStereo = new ImageToggle(this, toggleoffImage, toggleonImage); + fToggleStereo->setAbsolutePos(652, 72); + fToggleStereo->setId(ZamCompX2Plugin::paramStereo); fToggleStereo->setCallback(this); -} - -ZamCompX2UI::~ZamCompX2UI() -{ - delete fKnobAttack; - delete fKnobRelease; - delete fKnobThresh; - delete fKnobRatio; - delete fKnobKnee; - delete fKnobMakeup; - delete fToggleStereo; + // set default values + d_programChanged(0); } // ----------------------------------------------------------------------- @@ -152,8 +149,8 @@ void ZamCompX2UI::d_parameterChanged(uint32_t index, float value) } break; case ZamCompX2Plugin::paramStereo: - //fToggleStereo->setValue((int)value); - break; + fToggleStereo->setValue((int)value); + break; } } @@ -163,15 +160,13 @@ void ZamCompX2UI::d_programChanged(uint32_t index) return; // Default values - /* fKnobAttack->setValue(10.0f); fKnobRelease->setValue(80.0f); fKnobThresh->setValue(0.0f); fKnobRatio->setValue(4.0f); fKnobKnee->setValue(0.0f); fKnobMakeup->setValue(0.0f); - */ - //fToggleStereo->setValue(1.f); + fToggleStereo->setValue(1.0f); } // ----------------------------------------------------------------------- @@ -179,58 +174,24 @@ void ZamCompX2UI::d_programChanged(uint32_t index) void ZamCompX2UI::imageKnobDragStarted(ImageKnob* knob) { - if (knob == fKnobAttack) - d_editParameter(ZamCompX2Plugin::paramAttack, true); - else if (knob == fKnobRelease) - d_editParameter(ZamCompX2Plugin::paramRelease, true); - else if (knob == fKnobThresh) - d_editParameter(ZamCompX2Plugin::paramThresh, true); - else if (knob == fKnobRatio) - d_editParameter(ZamCompX2Plugin::paramRatio, true); - else if (knob == fKnobKnee) - d_editParameter(ZamCompX2Plugin::paramKnee, true); - else if (knob == fKnobMakeup) - d_editParameter(ZamCompX2Plugin::paramMakeup, true); + d_editParameter(knob->getId(), true); } void ZamCompX2UI::imageKnobDragFinished(ImageKnob* knob) { - if (knob == fKnobAttack) - d_editParameter(ZamCompX2Plugin::paramAttack, false); - else if (knob == fKnobRelease) - d_editParameter(ZamCompX2Plugin::paramRelease, false); - else if (knob == fKnobThresh) - d_editParameter(ZamCompX2Plugin::paramThresh, false); - else if (knob == fKnobRatio) - d_editParameter(ZamCompX2Plugin::paramRatio, false); - else if (knob == fKnobKnee) - d_editParameter(ZamCompX2Plugin::paramKnee, false); - else if (knob == fKnobMakeup) - d_editParameter(ZamCompX2Plugin::paramMakeup, false); + d_editParameter(knob->getId(), false); } void ZamCompX2UI::imageKnobValueChanged(ImageKnob* knob, float value) { - if (knob == fKnobAttack) - d_setParameterValue(ZamCompX2Plugin::paramAttack, value); - else if (knob == fKnobRelease) - d_setParameterValue(ZamCompX2Plugin::paramRelease, value); - else if (knob == fKnobThresh) - d_setParameterValue(ZamCompX2Plugin::paramThresh, value); - else if (knob == fKnobRatio) - d_setParameterValue(ZamCompX2Plugin::paramRatio, value); - else if (knob == fKnobKnee) - d_setParameterValue(ZamCompX2Plugin::paramKnee, value); - else if (knob == fKnobMakeup) - d_setParameterValue(ZamCompX2Plugin::paramMakeup, value); + d_setParameterValue(knob->getId(), value); } -void ZamCompX2UI::imageToggleClicked(ImageToggle *toggle, int) +void ZamCompX2UI::imageToggleClicked(ImageToggle* imageToggle, int) { - int flip = !toggle->getValue(); - if (toggle == fToggleStereo) { + int flip = !imageToggle->getValue(); + if (imageToggle == fToggleStereo) d_setParameterValue(ZamCompX2Plugin::paramStereo, flip); - } } void ZamCompX2UI::onDisplay() @@ -274,7 +235,7 @@ void ZamCompX2UI::onDisplay() else numRedLeds = 0; for (int i=numRedLeds; i>0; --i) - fLedRedImg.draw(sLedInitialX + (12 - i)*sLedSpacing, sRedLedStaticY); + fLedRedImg.drawAt(sLedInitialX + (12 - i)*sLedSpacing, sRedLedStaticY); if (fLedYellowValue >= 20.f) numYellowLeds = 19; @@ -318,12 +279,12 @@ void ZamCompX2UI::onDisplay() if (numYellowLeds > 12) { for (int i=12; i<numYellowLeds; ++i) - fLedRedImg.draw(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); + fLedRedImg.drawAt(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); for (int i=0; i<12; ++i) - fLedYellowImg.draw(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); + fLedYellowImg.drawAt(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); } else { for (int i=0; i<numYellowLeds; ++i) - fLedYellowImg.draw(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); + fLedYellowImg.drawAt(sLedInitialX + i*sLedSpacing, sYellowLedStaticY); } } diff --git a/plugins/ZamCompX2/ZamCompX2UI.hpp b/plugins/ZamCompX2/ZamCompX2UI.hpp index 26c7c19..e9601a0 100644 --- a/plugins/ZamCompX2/ZamCompX2UI.hpp +++ b/plugins/ZamCompX2/ZamCompX2UI.hpp @@ -1,6 +1,6 @@ /* - * ZamCompX2 stereo compressor - * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> + * ZamCompX2 stereo compressor + * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -24,7 +24,6 @@ #include "ImageToggle.hpp" #include "ZamCompX2Artwork.hpp" -#include "ZamCompX2Plugin.hpp" using DGL::Image; using DGL::ImageKnob; @@ -35,23 +34,22 @@ START_NAMESPACE_DISTRHO // ----------------------------------------------------------------------- class ZamCompX2UI : public UI, - public ImageKnob::Callback, - public ImageToggle::Callback + public ImageKnob::Callback, + public ImageToggle::Callback { public: ZamCompX2UI(); - ~ZamCompX2UI() override; protected: // ------------------------------------------------------------------- // Information - unsigned int d_getWidth() const noexcept override + uint d_getWidth() const noexcept override { return ZamCompX2Artwork::zamcompx2Width; } - unsigned int d_getHeight() const noexcept override + uint d_getHeight() const noexcept override { return ZamCompX2Artwork::zamcompx2Height; } @@ -68,21 +66,17 @@ protected: void imageKnobDragStarted(ImageKnob* knob) override; void imageKnobDragFinished(ImageKnob* knob) override; void imageKnobValueChanged(ImageKnob* knob, float value) override; - void imageToggleClicked(ImageToggle *toggle, int button) override; + void imageToggleClicked(ImageToggle* imageToggle, int button) override; void onDisplay() override; private: Image fImgBackground; - ImageKnob* fKnobAttack; - ImageKnob* fKnobRelease; - ImageKnob* fKnobThresh; - ImageKnob* fKnobRatio; - ImageKnob* fKnobKnee; - ImageKnob* fKnobMakeup; - - Image fImgToggleSlider; - ImageToggle* fToggleStereo; + ScopedPointer<ImageKnob> fKnobAttack, fKnobRelease, fKnobThresh; + ScopedPointer<ImageKnob> fKnobRatio, fKnobKnee, fKnobMakeup; + + Image fImgSwitchSlider; + ScopedPointer<ImageToggle> fToggleStereo; Image fLedRedImg; float fLedRedValue; diff --git a/plugins/ZamEQ2/Makefile b/plugins/ZamEQ2/Makefile index a89a89f..12f3148 100644 --- a/plugins/ZamEQ2/Makefile +++ b/plugins/ZamEQ2/Makefile @@ -20,13 +20,17 @@ OBJS_UI = \ ZamEQ2UI.cpp.o # -------------------------------------------------------------- -# No custom UI for now +# Do some magic -#TARGET_NOUI = true +include ../Makefile.mk # -------------------------------------------------------------- -# Do some magic +# Enable all possible plugin types -include ../Makefile.mk +ifeq ($(LINUX),true) +all: jack ladspa dssi lv2_sep vst +else +all: ladspa dssi lv2_sep vst +endif # -------------------------------------------------------------- diff --git a/plugins/ZamEQ2/ZamEQ2Plugin.cpp b/plugins/ZamEQ2/ZamEQ2Plugin.cpp index 05e2d5d..a704c0a 100644 --- a/plugins/ZamEQ2/ZamEQ2Plugin.cpp +++ b/plugins/ZamEQ2/ZamEQ2Plugin.cpp @@ -26,13 +26,6 @@ ZamEQ2Plugin::ZamEQ2Plugin() { // set default values d_setProgram(0); - - // reset - d_deactivate(); -} - -ZamEQ2Plugin::~ZamEQ2Plugin() -{ } // ----------------------------------------------------------------------- @@ -291,12 +284,6 @@ void ZamEQ2Plugin::d_activate() } } -void ZamEQ2Plugin::d_deactivate() -{ - // all values to zero -} - - void ZamEQ2Plugin::lowshelf(int i, int ch, float srate, float fc, float g) { float k, v0; @@ -307,7 +294,7 @@ void ZamEQ2Plugin::lowshelf(int i, int ch, float srate, float fc, float g) if (g < 0.f) { // LF cut float denom = v0 + sqrt(2. * v0)*k + k*k; - b0[ch][i] = v0 * (1. + sqrt(2.)*k + k*k) / denom; + b0[ch][i] = v0 * (1. + sqrt(2.)*k + k*k) / denom; b1[ch][i] = 2. * v0*(k*k - 1.) / denom; b2[ch][i] = v0 * (1. - sqrt(2.)*k + k*k) / denom; a1[ch][i] = 2. * (k*k - v0) / denom; @@ -369,7 +356,7 @@ void ZamEQ2Plugin::peq(int i, int ch, float srate, float fc, float g, float bw) // boost float denom = 1. + k/q + k*k; b0[ch][i] = (1. + k*v0/q + k*k) / denom; - b1[ch][i] = 2. * (k*k - 1.) / denom; + b1[ch][i] = 2. * (k*k - 1.) / denom; b2[ch][i] = (1. - k*v0/q + k*k) / denom; a1[ch][i] = b1[ch][i]; a2[ch][i] = (1. - k/q + k*k) / denom; @@ -380,7 +367,7 @@ float ZamEQ2Plugin::run_filter(int i, int ch, double in) { double out; in = sanitize_denormal(in); - out = in * b0[ch][i] + x1[ch][i] * b1[ch][i] + out = in * b0[ch][i] + x1[ch][i] * b1[ch][i] + x2[ch][i] * b2[ch][i] - y1[ch][i] * a1[ch][i] - y2[ch][i] * a2[ch][i] + 1e-20f; @@ -393,7 +380,7 @@ float ZamEQ2Plugin::run_filter(int i, int ch, double in) return (float) out; } -void ZamEQ2Plugin::d_run(float** inputs, float** outputs, uint32_t frames) +void ZamEQ2Plugin::d_run(const float** inputs, float** outputs, uint32_t frames) { float srate = d_getSampleRate(); diff --git a/plugins/ZamEQ2/ZamEQ2Plugin.hpp b/plugins/ZamEQ2/ZamEQ2Plugin.hpp index 7ff0521..43b36ab 100644 --- a/plugins/ZamEQ2/ZamEQ2Plugin.hpp +++ b/plugins/ZamEQ2/ZamEQ2Plugin.hpp @@ -1,5 +1,5 @@ /* - * ZamEQ2 2 band parametric equaliser + * ZamEQ2 2 band parametric equaliser * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or @@ -47,7 +47,6 @@ public: }; ZamEQ2Plugin(); - ~ZamEQ2Plugin() override; protected: // ------------------------------------------------------------------- @@ -117,8 +116,7 @@ protected: } void d_activate() override; - void d_deactivate() override; - void d_run(float** inputs, float** outputs, uint32_t frames) override; + void d_run(const float** inputs, float** outputs, uint32_t frames) override; void peq(int i, int ch, float srate, float fc, float g, float bw); void lowshelf(int i, int ch, float srate, float fc, float g); diff --git a/plugins/ZamEQ2/ZamEQ2UI.cpp b/plugins/ZamEQ2/ZamEQ2UI.cpp index a00248a..c368754 100644 --- a/plugins/ZamEQ2/ZamEQ2UI.cpp +++ b/plugins/ZamEQ2/ZamEQ2UI.cpp @@ -1,6 +1,6 @@ /* * ZamEQ2 2 band parametric equaliser - * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> + * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -35,79 +35,79 @@ ZamEQ2UI::ZamEQ2UI() // knob Image knobImage(ZamEQ2Artwork::knobData, ZamEQ2Artwork::knobWidth, ZamEQ2Artwork::knobHeight); - // knob + // knob fKnobGain1 = new ImageKnob(this, knobImage); - fKnobGain1->setPos(91, 172); + fKnobGain1->setAbsolutePos(91, 172); fKnobGain1->setRange(-50.f, 20.0f); fKnobGain1->setRotationAngle(240); fKnobGain1->setDefault(0.0f); fKnobGain1->setCallback(this); fKnobQ1 = new ImageKnob(this, knobImage); - fKnobQ1->setPos(91, 122); + fKnobQ1->setAbsolutePos(91, 122); fKnobQ1->setRange(0.1f, 6.0f); - fKnobQ1->setLogScale(true); + fKnobQ1->setUsingLogScale(true); fKnobQ1->setRotationAngle(240); fKnobQ1->setDefault(1.0f); fKnobQ1->setCallback(this); fKnobFreq1 = new ImageKnob(this, knobImage); - fKnobFreq1->setPos(23, 144); + fKnobFreq1->setAbsolutePos(23, 144); fKnobFreq1->setRange(20.f, 14000.0f); - fKnobFreq1->setLogScale(true); + fKnobFreq1->setUsingLogScale(true); fKnobFreq1->setRotationAngle(240); fKnobFreq1->setDefault(500.0f); fKnobFreq1->setCallback(this); fKnobGain2 = new ImageKnob(this, knobImage); - fKnobGain2->setPos(567, 172); + fKnobGain2->setAbsolutePos(567, 172); fKnobGain2->setRange(-50.f, 20.0f); fKnobGain2->setRotationAngle(240); fKnobGain2->setDefault(0.0f); fKnobGain2->setCallback(this); fKnobQ2 = new ImageKnob(this, knobImage); - fKnobQ2->setPos(567, 122); + fKnobQ2->setAbsolutePos(567, 122); fKnobQ2->setRange(0.1f, 6.0f); - fKnobQ2->setLogScale(true); + fKnobQ2->setUsingLogScale(true); fKnobQ2->setRotationAngle(240); fKnobQ2->setDefault(1.0f); fKnobQ2->setCallback(this); fKnobFreq2 = new ImageKnob(this, knobImage); - fKnobFreq2->setPos(499, 144); + fKnobFreq2->setAbsolutePos(499, 144); fKnobFreq2->setRange(20.f, 14000.0f); - fKnobFreq2->setLogScale(true); + fKnobFreq2->setUsingLogScale(true); fKnobFreq2->setRotationAngle(240); fKnobFreq2->setDefault(3000.0f); fKnobFreq2->setCallback(this); fKnobGainL = new ImageKnob(this, knobImage); - fKnobGainL->setPos(91, 52); + fKnobGainL->setAbsolutePos(91, 52); fKnobGainL->setRange(-50.f, 20.0f); fKnobGainL->setRotationAngle(240); fKnobGainL->setDefault(0.0f); fKnobGainL->setCallback(this); fKnobFreqL = new ImageKnob(this, knobImage); - fKnobFreqL->setPos(23, 23); + fKnobFreqL->setAbsolutePos(23, 23); fKnobFreqL->setRange(20.f, 14000.0f); - fKnobFreqL->setLogScale(true); + fKnobFreqL->setUsingLogScale(true); fKnobFreqL->setRotationAngle(240); fKnobFreqL->setDefault(250.0f); fKnobFreqL->setCallback(this); fKnobGainH = new ImageKnob(this, knobImage); - fKnobGainH->setPos(567, 53); + fKnobGainH->setAbsolutePos(567, 53); fKnobGainH->setRange(-50.f, 20.0f); fKnobGainH->setRotationAngle(240); fKnobGainH->setDefault(0.0f); fKnobGainH->setCallback(this); fKnobFreqH = new ImageKnob(this, knobImage); - fKnobFreqH->setPos(499, 24); + fKnobFreqH->setAbsolutePos(499, 24); fKnobFreqH->setRange(20.f, 14000.0f); - fKnobFreqH->setLogScale(true); + fKnobFreqH->setUsingLogScale(true); fKnobFreqH->setRotationAngle(240); fKnobFreqH->setDefault(8000.0f); fKnobFreqH->setCallback(this); @@ -122,24 +122,12 @@ ZamEQ2UI::ZamEQ2UI() fSliderMaster->setValue(0.f); fSliderMaster->setStep(6.f); fSliderMaster->setCallback(this); - + fCanvasArea.setPos(165,10); fCanvasArea.setSize(305,180); -} -ZamEQ2UI::~ZamEQ2UI() -{ - delete fKnobGain1; - delete fKnobQ1; - delete fKnobFreq1; - delete fKnobGain2; - delete fKnobQ2; - delete fKnobFreq2; - delete fKnobGainL; - delete fKnobFreqL; - delete fKnobGainH; - delete fKnobFreqH; - delete fSliderMaster; + // set default values + d_programChanged(0); } // ----------------------------------------------------------------------- @@ -309,7 +297,7 @@ void ZamEQ2UI::lowshelf(int i, int ch, float srate, float fc, float g) if (g < 0.f) { // LF cut float denom = v0 + sqrt(2. * v0)*k + k*k; - b0[ch][i] = v0 * (1. + sqrt(2.)*k + k*k) / denom; + b0[ch][i] = v0 * (1. + sqrt(2.)*k + k*k) / denom; b1[ch][i] = 2. * v0*(k*k - 1.) / denom; b2[ch][i] = v0 * (1. - sqrt(2.)*k + k*k) / denom; a1[ch][i] = 2. * (k*k - v0) / denom; @@ -371,7 +359,7 @@ void ZamEQ2UI::peq(int i, int ch, float srate, float fc, float g, float bw) // boost float denom = 1. + k/q + k*k; b0[ch][i] = (1. + k*v0/q + k*k) / denom; - b1[ch][i] = 2. * (k*k - 1.) / denom; + b1[ch][i] = 2. * (k*k - 1.) / denom; b2[ch][i] = (1. - k*v0/q + k*k) / denom; a1[ch][i] = b1[ch][i]; a2[ch][i] = (1. - k/q + k*k) / denom; @@ -437,14 +425,14 @@ void ZamEQ2UI::onDisplay() glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_LINE_SMOOTH); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); - + glLineWidth(2); int i; glColor4f(1.f, 1.f, 0.235f, 1.0f); for (i = 1; i < EQPOINTS; ++i) { glBegin(GL_LINES); if (eqy[i-1] < fCanvasArea.getY() + fCanvasArea.getHeight() - && eqy[i] < fCanvasArea.getY() + fCanvasArea.getHeight() + && eqy[i] < fCanvasArea.getY() + fCanvasArea.getHeight() && eqy[i-1] > fCanvasArea.getY() && eqy[i] > fCanvasArea.getY()) { glVertex2i(eqx[i-1], eqy[i-1]); diff --git a/plugins/ZamEQ2/ZamEQ2UI.hpp b/plugins/ZamEQ2/ZamEQ2UI.hpp index 716f1cd..6bb4100 100644 --- a/plugins/ZamEQ2/ZamEQ2UI.hpp +++ b/plugins/ZamEQ2/ZamEQ2UI.hpp @@ -1,6 +1,6 @@ /* * ZamEQ2 2 band parametric equaliser - * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> + * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -18,9 +18,6 @@ #ifndef ZAMEQ2UI_HPP_INCLUDED #define ZAMEQ2UI_HPP_INCLUDED -#define EQPOINTS 1000 -#include <complex> - #include "DistrhoUI.hpp" #include "ImageKnob.hpp" @@ -29,6 +26,9 @@ #include "ZamEQ2Artwork.hpp" #include "ZamEQ2Plugin.hpp" +#define EQPOINTS 1000 +#include <complex> + using DGL::Image; using DGL::ImageKnob; using DGL::ImageSlider; @@ -38,23 +38,22 @@ START_NAMESPACE_DISTRHO // ----------------------------------------------------------------------- class ZamEQ2UI : public UI, - public ImageKnob::Callback, - public ImageSlider::Callback + public ImageKnob::Callback, + public ImageSlider::Callback { public: ZamEQ2UI(); - ~ZamEQ2UI() override; protected: // ------------------------------------------------------------------- // Information - unsigned int d_getWidth() const noexcept override + uint d_getWidth() const noexcept override { return ZamEQ2Artwork::zameq2Width; } - unsigned int d_getHeight() const noexcept override + uint d_getHeight() const noexcept override { return ZamEQ2Artwork::zameq2Height; } @@ -105,6 +104,7 @@ protected: void peq(int i, int ch, float srate, float fc, float g, float bw); void lowshelf(int i, int ch, float srate, float fc, float g); void highshelf(int i, int ch, float srate, float fc, float g); + // ------------------------------------------------------------------- // DSP Callbacks @@ -126,17 +126,12 @@ protected: private: Image fImgBackground; - ImageKnob* fKnobGain1; - ImageKnob* fKnobQ1; - ImageKnob* fKnobFreq1; - ImageKnob* fKnobGain2; - ImageKnob* fKnobQ2; - ImageKnob* fKnobFreq2; - ImageKnob* fKnobGainL; - ImageKnob* fKnobFreqL; - ImageKnob* fKnobGainH; - ImageKnob* fKnobFreqH; - ImageSlider* fSliderMaster; + ScopedPointer<ImageKnob> fKnobGain1; + ScopedPointer<ImageKnob> fKnobQ1, fKnobFreq1, fKnobGain2; + ScopedPointer<ImageKnob> fKnobQ2, fKnobFreq2; + ScopedPointer<ImageKnob> fKnobGainL, fKnobFreqL; + ScopedPointer<ImageKnob> fKnobGainH, fKnobFreqH; + ScopedPointer<ImageSlider> fSliderMaster; float eqx[EQPOINTS]; float eqy[EQPOINTS]; DGL::Rectangle<int> fCanvasArea; diff --git a/plugins/ZamSynth/Makefile b/plugins/ZamSynth/Makefile index 90eb759..56a0426 100644 --- a/plugins/ZamSynth/Makefile +++ b/plugins/ZamSynth/Makefile @@ -20,13 +20,17 @@ OBJS_UI = \ ZamSynthUI.cpp.o # -------------------------------------------------------------- -# No custom UI for now +# Do some magic -#TARGET_NOUI = true +include ../Makefile.mk # -------------------------------------------------------------- -# Do some magic +# Enable all possible plugin types -include ../Makefile.mk +ifeq ($(LINUX),true) +all: jack dssi lv2_sep vst +else +all: dssi lv2_sep vst +endif # -------------------------------------------------------------- diff --git a/plugins/ZamSynth/ZamSynthPlugin.cpp b/plugins/ZamSynth/ZamSynthPlugin.cpp index 7ee1f51..d8dcd6a 100644 --- a/plugins/ZamSynth/ZamSynthPlugin.cpp +++ b/plugins/ZamSynth/ZamSynthPlugin.cpp @@ -26,13 +26,6 @@ ZamSynthPlugin::ZamSynthPlugin() { // set default values d_setProgram(0); - - // reset - d_deactivate(); -} - -ZamSynthPlugin::~ZamSynthPlugin() -{ } // ----------------------------------------------------------------------- @@ -137,7 +130,7 @@ void ZamSynthPlugin::d_setProgram(uint32_t index) voice[i].vi = 0.f; voice[i].rampstate = 0.f; } - + curvoice = voice; //ptr to first voice for (int i = 0; i < AREAHEIGHT; i++) { @@ -193,12 +186,6 @@ void ZamSynthPlugin::d_activate() { } -void ZamSynthPlugin::d_deactivate() -{ - // all values to zero -} - - float ZamSynthPlugin::wavetable(float in) { int index = (int) ((in / (2.0 * M_PI)) * (AREAHEIGHT-1.0)); @@ -206,14 +193,14 @@ float ZamSynthPlugin::wavetable(float in) //return (sin(in)); } -void ZamSynthPlugin::d_run(float**, float** outputs, uint32_t frames, +void ZamSynthPlugin::d_run(const float**, float** outputs, uint32_t frames, const MidiEvent* midievent, uint32_t midicount) { float srate = d_getSampleRate(); int slowfactor = (int) srate / (speed * 2400); // 1-20 ~ 20-1 uint32_t i; float RD_0; - + for (i = 0; i < midicount; i++) { int type = midievent[i].buf[0] & 0xF0; int chan = midievent[i].buf[0] & 0x0F; @@ -252,7 +239,7 @@ void ZamSynthPlugin::d_run(float**, float** outputs, uint32_t frames, } } } - + float power; bool signal; float wave; diff --git a/plugins/ZamSynth/ZamSynthPlugin.hpp b/plugins/ZamSynth/ZamSynthPlugin.hpp index 7325ed3..4fae641 100644 --- a/plugins/ZamSynth/ZamSynthPlugin.hpp +++ b/plugins/ZamSynth/ZamSynthPlugin.hpp @@ -1,5 +1,5 @@ /* - * ZamSynth polyphonic synthesiser + * ZamSynth polyphonic synthesiser * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or @@ -40,7 +40,6 @@ public: }; ZamSynthPlugin(); - ~ZamSynthPlugin() override; protected: // ------------------------------------------------------------------- @@ -106,8 +105,7 @@ protected: float wavetable(float in); void d_activate() override; - void d_deactivate() override; - void d_run(float** inputs, float** outputs, uint32_t frames, + void d_run(const float** inputs, float** outputs, uint32_t frames, const MidiEvent* midievent, uint32_t midicount) override; void d_setState(const char* key, const char* value) override; void d_initStateKey(unsigned int key, d_string& val) override; diff --git a/plugins/ZamSynth/ZamSynthUI.cpp b/plugins/ZamSynth/ZamSynthUI.cpp index 81e7d59..92233be 100644 --- a/plugins/ZamSynth/ZamSynthUI.cpp +++ b/plugins/ZamSynth/ZamSynthUI.cpp @@ -1,6 +1,6 @@ /* - * ZamSynth polyphonic synthesiser - * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> + * ZamSynth polyphonic synthesiser + * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -15,10 +15,9 @@ * For a full copy of the GNU General Public License see the doc/GPL.txt file. */ +#include "ZamSynthPlugin.hpp" #include "ZamSynthUI.hpp" -using DGL::Point; - START_NAMESPACE_DISTRHO // ----------------------------------------------------------------------- @@ -29,6 +28,9 @@ ZamSynthUI::ZamSynthUI() // background fImgBackground = Image(ZamSynthArtwork::zamsynthData, ZamSynthArtwork::zamsynthWidth, ZamSynthArtwork::zamsynthHeight, GL_BGR); + fDragging = false; + fDragValid = false; + // knob Image knobImage(ZamSynthArtwork::knobData, ZamSynthArtwork::knobWidth, ZamSynthArtwork::knobHeight); @@ -40,17 +42,17 @@ ZamSynthUI::ZamSynthUI() Image toggleonImage(ZamSynthArtwork::toggleonData, ZamSynthArtwork::toggleonWidth, ZamSynthArtwork::toggleonHeight); Image toggleoffImage(ZamSynthArtwork::toggleoffData, ZamSynthArtwork::toggleoffWidth, ZamSynthArtwork::toggleoffHeight); - // knob + // knob fKnobGain = new ImageKnob(this, knobImage); - fKnobGain->setPos(284.75, 240); + fKnobGain->setAbsolutePos(284.75, 240); fKnobGain->setRange(-30.f, 30.0f); fKnobGain->setDefault(0.0f); fKnobGain->setRotationAngle(240); fKnobGain->setCallback(this); fKnobSpeed = new ImageKnob(this, knobImage); - fKnobSpeed->setPos(284.75, 92.5); + fKnobSpeed->setAbsolutePos(284.75, 92.5); fKnobSpeed->setRange(1.f, 20.0f); fKnobSpeed->setDefault(10.0f); fKnobSpeed->setStep(1.0f); @@ -59,7 +61,7 @@ ZamSynthUI::ZamSynthUI() // button fButtonSmooth = new ImageButton(this, smoothrImage, smoothrImage, smoothyImage); - fButtonSmooth->setPos(265, 165); + fButtonSmooth->setAbsolutePos(265, 165); fButtonSmooth->setCallback(this); // drawing area @@ -71,18 +73,13 @@ ZamSynthUI::ZamSynthUI() } // toggle - fToggleGraph = new ImageToggle(this, toggleonImage, toggleoffImage, toggleoffImage); - fToggleGraph->setPos(300, 33); + fToggleGraph = new ImageToggle(this, toggleonImage, toggleoffImage); + fToggleGraph->setAbsolutePos(300, 33); fToggleGraph->setCallback(this); fToggleGraph->setValue(0.f); -} -ZamSynthUI::~ZamSynthUI() -{ - delete fKnobGain; - delete fKnobSpeed; - delete fButtonSmooth; - delete fToggleGraph; + // set default values + d_programChanged(0); } void ZamSynthUI::d_stateChanged(const char* key, const char* value) @@ -183,7 +180,7 @@ void ZamSynthUI::imageButtonClicked(ImageButton*, int) gaussiansmooth(wavesmooth, xs, gr, AREAHEIGHT, 4); memcpy(gr, wavesmooth, AREAHEIGHT*sizeof(float)); - + char tmp[4*AREAHEIGHT+1] = {0}; for(i = 0; i < AREAHEIGHT; i++) { char wavestr[5] = {0}; @@ -191,7 +188,7 @@ void ZamSynthUI::imageButtonClicked(ImageButton*, int) strcat(tmp, wavestr); } - if (fToggleGraph->getValue() == 1.f) + if (fToggleGraph->getValue() == 1.f) d_setState("envelope", tmp); else d_setState("waveform", tmp); @@ -201,7 +198,7 @@ void ZamSynthUI::imageToggleClicked(ImageToggle*, int) { float toggle = fToggleGraph->getValue(); fToggleGraph->setValue(toggle); - d_setParameterValue(ZamSynthPlugin::paramGraph, toggle); + d_setParameterValue(ZamSynthPlugin::paramGraph, toggle); } void ZamSynthUI::gaussiansmooth(float* smoothed, float* xs, float* ys, int n, int radius) @@ -222,14 +219,14 @@ void ZamSynthUI::gaussiansmooth(float* smoothed, float* xs, float* ys, int n, in } } -bool ZamSynthUI::onMouse(int button, bool press, int x, int y) +bool ZamSynthUI::onMouse(const MouseEvent& ev) { - if (button != 1) + if (ev.button != 1) return false; - if (press) + if (ev.press) { - if (! fCanvasArea.contains(x, y)) { + if (! fCanvasArea.contains(ev.pos)) { //fDragValid = false; return false; } @@ -247,7 +244,7 @@ bool ZamSynthUI::onMouse(int button, bool press, int x, int y) return false; } -bool ZamSynthUI::onMotion(int x, int y) +bool ZamSynthUI::onMotion(const MotionEvent& ev) { if (! fDragging) return false; @@ -255,15 +252,18 @@ bool ZamSynthUI::onMotion(int x, int y) { fDragValid = true; } - + + int x = ev.pos.getX(); + int y = ev.pos.getY(); + if (x > fCanvasArea.getWidth()+10) x = fCanvasArea.getWidth()+10; if (x < 10) x = 10; if (y < 10) y = 10; - + float *gr; if (fToggleGraph->getValue() == 0.f) { - gr = wave_y; + gr = wave_y; if (y > fCanvasArea.getHeight()+10) y = fCanvasArea.getHeight()+10; } else { @@ -271,7 +271,7 @@ bool ZamSynthUI::onMotion(int x, int y) if (y > fCanvasArea.getHeight() / 2. + 10) y = fCanvasArea.getHeight() / 2. + 10; } - + if (gr[x-10] != (y-10)) { char tmp[4*AREAHEIGHT+1] = {0}; int i; @@ -282,12 +282,12 @@ bool ZamSynthUI::onMotion(int x, int y) } gr[x-10] = y-10; - + if (gr == env_y) d_setState("envelope",tmp); else d_setState("waveform",tmp); - + repaint(); } diff --git a/plugins/ZamSynth/ZamSynthUI.hpp b/plugins/ZamSynth/ZamSynthUI.hpp index 6fc2867..291990f 100644 --- a/plugins/ZamSynth/ZamSynthUI.hpp +++ b/plugins/ZamSynth/ZamSynthUI.hpp @@ -1,6 +1,6 @@ /* * ZamSynth polyphonic synthesiser - * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> + * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -20,50 +20,47 @@ #include "DistrhoUI.hpp" -#include "Geometry.hpp" -#include "ImageKnob.hpp" #include "ImageButton.hpp" +#include "ImageKnob.hpp" #include "ImageToggle.hpp" #include "ZamSynthArtwork.hpp" -#include "ZamSynthPlugin.hpp" + +#define AREAHEIGHT 250 using DGL::Image; -using DGL::ImageKnob; using DGL::ImageButton; +using DGL::ImageKnob; using DGL::ImageToggle; -#define AREAHEIGHT 250 - START_NAMESPACE_DISTRHO // ----------------------------------------------------------------------- class ZamSynthUI : public UI, - public ImageKnob::Callback, - public ImageButton::Callback, - public ImageToggle::Callback + public ImageButton::Callback, + public ImageKnob::Callback, + public ImageToggle::Callback { public: ZamSynthUI(); - ~ZamSynthUI() override; protected: // ------------------------------------------------------------------- // Information - unsigned int d_getWidth() const noexcept override + uint d_getWidth() const noexcept override { return ZamSynthArtwork::zamsynthWidth; } - unsigned int d_getHeight() const noexcept override + uint d_getHeight() const noexcept override { return ZamSynthArtwork::zamsynthHeight; } void gaussiansmooth(float* smoothed, float* xs, float* ys, int n, int radius); - + // ------------------------------------------------------------------- // DSP Callbacks @@ -82,15 +79,14 @@ protected: void imageToggleClicked(ImageToggle* toggle, int) override; void onDisplay() override; - bool onMouse(int, bool, int, int) override; - bool onMotion(int, int) override; + bool onMouse(const MouseEvent&) override; + bool onMotion(const MotionEvent&) override; private: Image fImgBackground; - ImageKnob* fKnobGain; - ImageKnob* fKnobSpeed; - ImageButton* fButtonSmooth; - ImageToggle* fToggleGraph; + ScopedPointer<ImageKnob> fKnobGain, fKnobSpeed; + ScopedPointer<ImageButton> fButtonSmooth; + ScopedPointer<ImageToggle> fToggleGraph; float wave_y[AREAHEIGHT]; float env_y[AREAHEIGHT]; bool fGraph; diff --git a/plugins/ZamTube/Makefile b/plugins/ZamTube/Makefile index 8f7ebb7..6cc51d7 100644 --- a/plugins/ZamTube/Makefile +++ b/plugins/ZamTube/Makefile @@ -21,13 +21,17 @@ OBJS_UI = \ ZamTubeUI.cpp.o # -------------------------------------------------------------- -# No custom UI for now +# Do some magic -#TARGET_NOUI = true +include ../Makefile.mk # -------------------------------------------------------------- -# Do some magic +# Enable all possible plugin types -include ../Makefile.mk +ifeq ($(LINUX),true) +all: jack ladspa dssi lv2_sep vst +else +all: ladspa dssi lv2_sep vst +endif # -------------------------------------------------------------- diff --git a/plugins/ZamTube/ZamTubePlugin.cpp b/plugins/ZamTube/ZamTubePlugin.cpp index b72b0fd..3134b89 100644 --- a/plugins/ZamTube/ZamTubePlugin.cpp +++ b/plugins/ZamTube/ZamTubePlugin.cpp @@ -33,13 +33,6 @@ ZamTubePlugin::ZamTubePlugin() { // set default values d_setProgram(0); - - // reset - d_deactivate(); -} - -ZamTubePlugin::~ZamTubePlugin() -{ } // ----------------------------------------------------------------------- @@ -288,12 +281,7 @@ void ZamTubePlugin::d_activate() for (int i=0; i<4; i++) fRec24[i] = 0; } -void ZamTubePlugin::d_deactivate() -{ - // all values to zero -} - -void ZamTubePlugin::d_run(float** inputs, float** outputs, uint32_t frames) +void ZamTubePlugin::d_run(const float** inputs, float** outputs, uint32_t frames) { T tubetone = 0.f; diff --git a/plugins/ZamTube/ZamTubePlugin.hpp b/plugins/ZamTube/ZamTubePlugin.hpp index c5dadb6..3c42730 100644 --- a/plugins/ZamTube/ZamTubePlugin.hpp +++ b/plugins/ZamTube/ZamTubePlugin.hpp @@ -1,6 +1,6 @@ /* - * ZamTube triode WDF distortion model - * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> + * ZamTube triode WDF distortion model + * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -25,13 +25,9 @@ START_NAMESPACE_DISTRHO // ----------------------------------------------------------------------- - -#include <stdint.h> -#include <math.h> - -template <int N> inline float faustpower(float x) { return powf(x,N); } +template <int N> inline float faustpower(float x) { return powf(x,N); } template <int N> inline double faustpower(double x) { return pow(x,N); } -template <int N> inline int faustpower(int x) { return faustpower<N/2>(x) * faustpower<N-N/2>(x); } +template <int N> inline int faustpower(int x) { return faustpower<N/2>(x) * faustpower<N-N/2>(x); } template <> inline int faustpower<0>(int) { return 1; } template <> inline int faustpower<1>(int x) { return x; } @@ -119,7 +115,6 @@ public: }; ZamTubePlugin(); - ~ZamTubePlugin() override; protected: // ------------------------------------------------------------------- @@ -184,8 +179,7 @@ protected: } void d_activate() override; - void d_deactivate() override; - void d_run(float** inputs, float** outputs, uint32_t frames) override; + void d_run(const float** inputs, float** outputs, uint32_t frames) override; // ------------------------------------------------------------------- diff --git a/plugins/ZamTube/ZamTubeUI.cpp b/plugins/ZamTube/ZamTubeUI.cpp index a4e9e6b..e18c7ee 100644 --- a/plugins/ZamTube/ZamTubeUI.cpp +++ b/plugins/ZamTube/ZamTubeUI.cpp @@ -1,6 +1,6 @@ /* * ZamTube triode WDF distortion model - * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> + * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -15,6 +15,12 @@ * For a full copy of the GNU General Public License see the doc/GPL.txt file. */ +#include "ZamTubePlugin.hpp" + +// conflict macros in wdf +#undef max +#undef min + #include "ZamTubeUI.hpp" using DGL::Point; @@ -35,9 +41,9 @@ ZamTubeUI::ZamTubeUI() // notch slider Image notchImage(ZamTubeArtwork::notchData, ZamTubeArtwork::notchWidth, ZamTubeArtwork::notchHeight); - // knobs + // knobs fKnobTube = new ImageKnob(this, knobImage); - fKnobTube->setPos(177, 76); + fKnobTube->setAbsolutePos(177, 76); fKnobTube->setRange(0.f, 30.0f); fKnobTube->setStep(0.1f); fKnobTube->setDefault(0.0f); @@ -45,7 +51,7 @@ ZamTubeUI::ZamTubeUI() fKnobTube->setCallback(this); fKnobBass = new ImageKnob(this, knobImage); - fKnobBass->setPos(63, 140.5); + fKnobBass->setAbsolutePos(63, 140.5); fKnobBass->setRange(0.f, 1.0f); fKnobBass->setStep(0.01f); fKnobBass->setDefault(0.5f); @@ -53,7 +59,7 @@ ZamTubeUI::ZamTubeUI() fKnobBass->setCallback(this); fKnobMids = new ImageKnob(this, knobImage); - fKnobMids->setPos(63, 87); + fKnobMids->setAbsolutePos(63, 87); fKnobMids->setRange(0.f, 1.0f); fKnobMids->setStep(0.01f); fKnobMids->setDefault(0.5f); @@ -61,7 +67,7 @@ ZamTubeUI::ZamTubeUI() fKnobMids->setCallback(this); fKnobTreb = new ImageKnob(this, knobImage); - fKnobTreb->setPos(63, 33); + fKnobTreb->setAbsolutePos(63, 33); fKnobTreb->setRange(0.f, 1.0f); fKnobTreb->setStep(0.01f); fKnobTreb->setDefault(0.0f); @@ -69,7 +75,7 @@ ZamTubeUI::ZamTubeUI() fKnobTreb->setCallback(this); fKnobGain = new ImageKnob(this, knobImage); - fKnobGain->setPos(63, 231); + fKnobGain->setAbsolutePos(63, 231); fKnobGain->setRange(-30.f, 30.0f); fKnobGain->setStep(1.f); fKnobGain->setDefault(0.0f); @@ -86,16 +92,9 @@ ZamTubeUI::ZamTubeUI() fSliderNotch->setStep(1.f); fSliderNotch->setValue(0.f); fSliderNotch->setCallback(this); -} -ZamTubeUI::~ZamTubeUI() -{ - delete fKnobTube; - delete fKnobBass; - delete fKnobMids; - delete fKnobTreb; - delete fKnobGain; - delete fSliderNotch; + // set default values + d_programChanged(0); } // ----------------------------------------------------------------------- diff --git a/plugins/ZamTube/ZamTubeUI.hpp b/plugins/ZamTube/ZamTubeUI.hpp index f73dc5d..b992eda 100644 --- a/plugins/ZamTube/ZamTubeUI.hpp +++ b/plugins/ZamTube/ZamTubeUI.hpp @@ -1,6 +1,6 @@ /* - * ZamTube triode WDF distortion model - * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> + * ZamTube triode WDF distortion model + * Copyright (C) 2014 Damien Zammit <damien@zamaudio.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -24,7 +24,6 @@ #include "ImageSlider.hpp" #include "ZamTubeArtwork.hpp" -#include "ZamTubePlugin.hpp" using DGL::Image; using DGL::ImageKnob; @@ -35,23 +34,22 @@ START_NAMESPACE_DISTRHO // ----------------------------------------------------------------------- class ZamTubeUI : public UI, - public ImageKnob::Callback, - public ImageSlider::Callback + public ImageKnob::Callback, + public ImageSlider::Callback { public: ZamTubeUI(); - ~ZamTubeUI() override; protected: // ------------------------------------------------------------------- // Information - unsigned int d_getWidth() const noexcept override + uint d_getWidth() const noexcept override { return ZamTubeArtwork::zamtubeWidth; } - unsigned int d_getHeight() const noexcept override + uint d_getHeight() const noexcept override { return ZamTubeArtwork::zamtubeHeight; } @@ -77,12 +75,8 @@ protected: private: Image fImgBackground; - ImageKnob* fKnobTube; - ImageKnob* fKnobBass; - ImageKnob* fKnobMids; - ImageKnob* fKnobTreb; - ImageKnob* fKnobGain; - ImageSlider* fSliderNotch; + ScopedPointer<ImageSlider> fSliderNotch; + ScopedPointer<ImageKnob> fKnobTube, fKnobBass, fKnobMids, fKnobTreb, fKnobGain; }; // ----------------------------------------------------------------------- |