rays 0.3.12 → 0.3.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b820979b1e5f5cc65ad457a6614bf068a15f03f0351709367e007a5046b02747
-  data.tar.gz: b80a61f404fb951e609cc449cc155450aaaf2c7d0f6a2eab39001d5bd8cdc8aa
+  metadata.gz: be106158650d37c835a8396c0ce079a3bc829f6fdd10fed78153f5bba6e0246d
+  data.tar.gz: 833c9b8cd83d1e484d8424991cffd89af1a4af0a31eead4cfe8ea52db0dacead
 SHA512:
-  metadata.gz: 9fa68f150b09b3ac24e47d8cb36c6deb4f68047755b9d5da8daccd44b568655650e6b96b4043d3c1d148bb61fc782f0a39f01dfd0ea950e078f866c0b4d1ad8c
-  data.tar.gz: b83ee77854124708af2d926de0f354e01263362fa385feb0d30a8ad3c88c522fda44d1537ba9df73c9b07570a8e6214300c858c44584535d68b3bc10a8cdfb02
+  metadata.gz: ff626e5099d975fa64f4990d3c4ee12265612dde05b56103354f1cbbbbba6653770c183b262b757d103bf3e1c31824813d1afe66b3445c33090448587c81441a
+  data.tar.gz: 590f20a70dc9505ab609482ce98ff7fbcc9eddbdf03271597869dfadbec55a307f775327c41ffa7f630eef5d7dc7c0c6344d78070e9c5888f2c3bdef0f1de7cf

data/.github/workflows/release-gem.yml

@@ -36,23 +36,9 @@ jobs:
           echo path=$(ruby -e 'print Dir.glob("*.gem").first') >> $GITHUB_OUTPUT
 
       - name: create github release
-        id: release
-        uses: actions/create-release@v1
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: ${{ github.ref }}
-
-      - name: upload to github release
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.release.outputs.upload_url }}
-          asset_path: ./${{ steps.gem.outputs.path }}
-          asset_name:   ${{ steps.gem.outputs.path }}
-          asset_content_type: application/zip
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: ruby -I.github/workflows -rutils -e 'release(*ARGV)' ./${{ steps.gem.outputs.path }}
 
       - name: upload to rubygems
         env:

data/ChangeLog.md

@@ -1,6 +1,15 @@
 # rays ChangeLog
 
 
+## [v0.3.13] - 2026-05-17
+
+- Improve batch rendering: defer flush until state actually changes
+- Rewrite README.md
+- CI: Migrate release-gem.yml from actions/create-release to gh release create
+
+- Fix text rendering corruption when batching is enabled
+
+
 ## [v0.3.12] - 2026-05-10
 
 - Support WebAssembly

data/README.md

@@ -1,4 +1,4 @@
-# Rays - A Drawing Engine using OpenGL.
+# Rays - A 2D drawing engine on OpenGL
 
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/xord/rays)
 ![License](https://img.shields.io/github/license/xord/rays)
@@ -21,18 +21,39 @@ Thanks for your support! 🙌
 
 ## 🚀 About
 
-**Rays** is a drawing engine that utilizes OpenGL for 2D rendering.
+**Rays** is a hardware-accelerated 2D drawing engine for Ruby. It is built on OpenGL and exposes a retained-mode-friendly API: build `Polygon`, `Polyline`, `Image`, `Shader`, and `Font` objects, then paint them into an off-screen `Image` (or a window provided by [Reflex](https://github.com/xord/reflex)) through a `Painter`.
 
-It is designed to provide efficient graphics capabilities, making it ideal for creating complex visualizations and graphics applications.
+It is the rendering layer used by [Reflex](https://github.com/xord/reflex), [Processing](https://github.com/xord/processing), [RubySketch](https://github.com/xord/rubysketch), and [Reight](https://github.com/xord/reight). Like the rest of the `xord/*` family, it is primarily developed for our own use, but it also works as a standalone drawing gem.
+
+## 📋 Requirements
+
+- Ruby **3.0.0** or later
+- A C++ compiler with C++20 support
+- [Xot](https://rubygems.org/gems/xot) and [Rucy](https://rubygems.org/gems/rucy) (declared as runtime dependencies)
+- Platform graphics backend:
+  - **macOS** — AppKit, OpenGL, AVFoundation (bundled with the OS)
+  - **iOS** — UIKit, OpenGL ES, AVFoundation (bundled with the OS)
+  - **Windows** — GDI32, OpenGL32, GLEW (`MINGW_PACKAGE_PREFIX-glew`)
+  - **Linux** — `libsdl2-dev`, `libsdl2-ttf-dev`, `libglew-dev`
+
+The following third-party libraries are cloned from GitHub and statically linked while the native extension is being built, so you do not need to install them separately:
+
+| Library                                                       | Role                                              |
+| ------------------------------------------------------------- | ------------------------------------------------- |
+| [GLM](https://github.com/g-truc/glm)                          | Vector / matrix math used internally              |
+| [Clipper](https://github.com/skyrpex/clipper)                 | Polygon Boolean operations (`+`, `-`, `&`, `\|`, `^`) |
+| [earcut.hpp](https://github.com/mapbox/earcut.hpp)            | Polygon triangulation                             |
+| [splines-lib](https://github.com/andrewwillmott/splines-lib)  | Curve / spline math                               |
+| [stb](https://github.com/nothings/stb) (Windows / Linux only) | Image file loading                                |
 
 ## 📦 Installation
 
 Add this line to your Gemfile:
 ```ruby
-$ gem 'rays'
+gem 'rays'
 ```
 
-Then, install gem:
+Then install:
 ```bash
 $ bundle install
 ```
@@ -42,7 +63,145 @@ Or install it directly:
 $ gem install rays
 ```
 
+`require 'rays'` automatically calls `Rays.init!` and registers `Rays.fin!` at exit. Set `$RAYS_NOAUTOINIT = true` before requiring if you want to manage the lifetime yourself.
+
+Rays needs a current OpenGL context. When used through [Reflex](https://github.com/xord/reflex), the window creates and binds a context for you. To use Rays standalone for off-screen rendering, it allocates a hidden context automatically.
+
+## 📚 What's Included
+
+### Geometry and color types
+
+| Class                | Purpose                                                          |
+| -------------------- | ---------------------------------------------------------------- |
+| `Rays::Point`        | 2D / 3D point with arithmetic operators                          |
+| `Rays::Bounds`       | Axis-aligned rectangle (position + size)                         |
+| `Rays::Color`        | RGBA color in floating-point components                          |
+| `Rays::ColorSpace`   | Pixel format / color space descriptor (RGBA, ARGB, GRAY, ...)    |
+| `Rays::Matrix`       | 4×4 transformation matrix                                        |
+
+### Drawing primitives
+
+| Class                | Purpose                                                                                      |
+| -------------------- | -------------------------------------------------------------------------------------------- |
+| `Rays::Polyline`     | A single open or closed polyline; expandable into a stroked polygon                          |
+| `Rays::Polygon`      | One or more polylines forming a closed shape; supports Boolean ops via `+`, `-`, `&`, `\|`, `^` |
+| `Rays::Image`        | A renderable texture with an associated `Painter` for off-screen drawing                     |
+| `Rays::Bitmap`       | CPU-side pixel buffer that can be uploaded to / downloaded from an `Image`                   |
+| `Rays::Font`         | Text rendering — created from a system font name and a size                                  |
+| `Rays::Shader`       | GLSL fragment / vertex shader with `set_uniform` / `uniform` for parameters                  |
+| `Rays::Camera`       | Live camera capture (per platform) rendered into an `Image`                                  |
+
+### The `Painter`
+
+`Rays::Painter` is the immediate-mode drawing surface. Obtain one through `Image#painter`, then between `painter.paint do |p| ... end` (or `begin_paint` / `end_paint`) issue draw calls:
+
+- **Shapes** — `point`, `line`, `rect`, `ellipse`, `curve`, `bezier`, `triangle`, `quad`, `polygon`
+- **Bitmaps & text** — `image`, `text`
+- **State** — `fill`, `stroke`, `background`, `stroke_width`, `stroke_cap`, `stroke_join`, `blend_mode`, `clip`, `font`, `texture`, `shader`
+- **Transforms** — `translate`, `scale`, `rotate`, `set_matrix`
+- **Push / pop** — `push(:state, :matrix)` / `pop`, or the block form `push(fill: ..., stroke: ...) { ... }`
+
+`stroke_cap`, `stroke_join`, `blend_mode`, `texcoord_mode`, `texcoord_wrap` accept symbols (e.g. `:round`, `:miter`, `:multiply`).
+
+### Top-level helpers
+
+- `Rays.init!` / `Rays.fin!` — explicit lifecycle (called automatically on `require`)
+- `Rays::Image.load(path)` / `Rays::Image#save(path)` — image file I/O
+- `Rays.renderer_info` — debug info about the current OpenGL context
+
+## 💡 Usage
+
+### Draw to an off-screen image and save it
+
+```ruby
+require 'rays'
+
+image = Rays::Image.new(200, 200)
+image.paint do |p|
+  p.background 0, 0, 0
+  p.fill   1, 0.4, 0.1     # orange-ish
+  p.stroke 1, 1, 1
+  p.stroke_width 4
+
+  p.rect 20, 20, 160, 160, round: 16
+  p.ellipse 100, 100, 60, 60
+end
+
+image.save 'out.png'
+```
+
+### Compose a polygon from Boolean operations
+
+```ruby
+require 'rays'
+
+a = Rays::Polygon.rect(0, 0, 100, 100)
+b = Rays::Polygon.ellipse(50, 50, 80, 80)
+
+union        = a | b   # outer outline of both
+difference   = a - b   # rectangle with circular bite
+intersection = a & b   # lens-shaped overlap
+xor          = a ^ b   # everything except the overlap
+
+Rays::Image.new(140, 140).paint {|p| p.fill 1; p.polygon difference }.save 'diff.png'
+```
+
+(The C++ operator names map to Ruby's `|`, `-`, `&`, `^`.)
+
+### Use a fragment shader
+
+```ruby
+require 'rays'
+
+invert = Rays::Shader.new <<~GLSL
+  uniform sampler2D texture;
+  varying vec4 vTexCoord;
+  void main() {
+    vec4 c = texture2D(texture, vTexCoord.xy);
+    gl_FragColor = vec4(1.0 - c.rgb, c.a);
+  }
+GLSL
+
+src = Rays::Image.load('photo.png')
+out = Rays::Image.new(src.width, src.height)
+out.paint do |p|
+  p.shader = invert
+  p.image src
+end
+out.save 'photo-invert.png'
+```
+
+### Drive `push` / `pop` with attributes
+
+```ruby
+image.paint do |p|
+  p.push(:state, :matrix, fill: [1, 0, 0]) do
+    p.translate 50, 50
+    p.rotate 30
+    p.rect -20, -20, 40, 40
+  end
+  # fill, state, and matrix are restored here
+end
+```
+
+## 🛠️ Development
+
+```bash
+$ rake vendor   # clone the external libraries into vendor/
+$ rake lib      # build the native C++ library (librays)
+$ rake ext      # build the Ruby C extension
+$ rake test     # run the test suite
+$ rake doc      # generate RDoc from C++ sources
+$ rake          # default: builds the extension
+```
+
+The drawing tests render into off-screen images and compare pixels, so they require a working OpenGL context. The `test_rays_init.rb` test must run in its own process and is listed in `TESTS_ALONE`.
+
+In the [`xord/all`](https://github.com/xord/all) monorepo you can scope by module, e.g. `rake rays test`.
+
 ## 📜 License
 
 **Rays** is licensed under the MIT License.
 See the [LICENSE](./LICENSE) file for details.
+
+The third-party libraries listed above retain their own licenses (all MIT-compatible: MIT, ISC, Boost-1.0, dual-licensed MIT/Happy-Bunny for GLM, Unlicense for splines-lib).

data/VERSION

@@ -1 +1 @@
-0.3.12
+0.3.13

data/rays.gemspec

@@ -25,8 +25,8 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 3.0.0'
 
-  s.add_dependency 'xot',  '~> 0.3.12'
-  s.add_dependency 'rucy', '~> 0.3.12'
+  s.add_dependency 'xot',  '~> 0.3.13'
+  s.add_dependency 'rucy', '~> 0.3.13'
 
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}

data/src/opengl/painter.cpp

@@ -24,6 +24,11 @@ namespace Rays
 {
 
 
+	static const Shader  INVALID_SHADER;
+
+	static const Texture INVALID_TEXTURE;
+
+
 	struct Vector4 : Coord4
 	{
 
@@ -140,11 +145,23 @@ namespace Rays
 	struct Batcher
 	{
 
+		GLuint cached_shader_id  = 0;
+
+		GLuint cached_texture_id = 0;
+
 		int count = 0;
 
-		Shader shader;
+		BlendMode blend_mode;
+
+		TexCoordMode texcoord_mode;
 
-		Texture texture;
+		TexCoordWrap texcoord_wrap;
+
+		Bounds clip;
+
+		Shader shader   = INVALID_SHADER;
+
+		Texture texture = INVALID_TEXTURE;
 
 		std::vector<Vector4> points;
 
@@ -158,11 +175,25 @@ namespace Rays
 
 		std::vector<Coord3>  texcoord_maxes;
 
-		void clear ()
+		void init (const PainterState& state)
 		{
-			count   = 0;
-			shader  = Shader();
-			texture = Texture();
+			cached_shader_id  = 0;
+			cached_texture_id = 0;
+			blend_mode        = state.blend_mode;
+			texcoord_mode     = state.texcoord_mode;
+			texcoord_wrap     = state.texcoord_wrap;
+			clip              = state.clip;
+		}
+
+		void cleanup ()
+		{
+			shader  = INVALID_SHADER;
+			texture = INVALID_TEXTURE;
+		}
+
+		void clear_buffers ()
+		{
+			count = 0;
 			points        .clear();
 			indices       .clear();
 			colors        .clear();
@@ -226,6 +257,83 @@ namespace Rays
 			buffers.clear();
 		}
 
+		void apply_blend_mode ()
+		{
+			switch (state.blend_mode)
+			{
+				case BLEND_NORMAL:
+					glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+					glBlendFuncSeparate(
+						GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE);
+					break;
+
+				case BLEND_ADD:
+					glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+					glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE, GL_ONE, GL_ONE);
+					break;
+
+				case BLEND_SUBTRACT:
+					glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_ADD);
+					glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE, GL_ONE, GL_ONE);
+					break;
+
+				case BLEND_LIGHTEST:
+					glBlendEquationSeparate(GL_MAX, GL_FUNC_ADD);
+					glBlendFuncSeparate(GL_ONE, GL_ONE, GL_ONE, GL_ONE);
+					break;
+
+				case BLEND_DARKEST:
+					glBlendEquationSeparate(GL_MIN, GL_FUNC_ADD);
+					glBlendFuncSeparate(GL_ONE, GL_ONE, GL_ONE, GL_ONE);
+					break;
+
+				case BLEND_EXCLUSION:
+					glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+					glBlendFuncSeparate(
+						GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_ONE, GL_ONE);
+					break;
+
+				case BLEND_MULTIPLY:
+					glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+					glBlendFuncSeparate(GL_ZERO, GL_SRC_COLOR, GL_ONE, GL_ONE);
+					break;
+
+				case BLEND_SCREEN:
+					glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+					glBlendFuncSeparate(GL_ONE_MINUS_DST_COLOR, GL_ONE, GL_ONE, GL_ONE);
+					break;
+
+				case BLEND_REPLACE:
+					glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+					glBlendFuncSeparate(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO);
+					break;
+
+				default:
+					argument_error(__FILE__, __LINE__, "unknown blend mode");
+					break;
+			}
+			OpenGL_check_error(__FILE__, __LINE__);
+		}
+
+		void apply_clipping ()
+		{
+			const Bounds& clip = state.clip;
+			if (clip)
+			{
+				coord y = frame_buffer ? clip.y : viewport.h - (clip.y + clip.h);
+				glEnable(GL_SCISSOR_TEST);
+				glScissor(
+					pixel_density * clip.x,
+					pixel_density * y,
+					pixel_density * clip.width,
+					pixel_density * clip.height);
+			}
+			else
+				glDisable(GL_SCISSOR_TEST);
+
+			OpenGL_check_error(__FILE__, __LINE__);
+		}
+
 	};// PainterData
 
 
@@ -235,27 +343,6 @@ namespace Rays
 		return (PainterData*) painter->self.get();
 	}
 
-	void
-	Painter_update_clip (Painter* painter)
-	{
-		PainterData* self = get_data(painter);
-		const Bounds& clip = self->state.clip;
-		if (clip)
-		{
-			coord y = self->frame_buffer ? clip.y : self->viewport.h - (clip.y + clip.h);
-			glEnable(GL_SCISSOR_TEST);
-			glScissor(
-				self->pixel_density * clip.x,
-				self->pixel_density * y,
-				self->pixel_density * clip.width,
-				self->pixel_density * clip.height);
-		}
-		else
-			glDisable(GL_SCISSOR_TEST);
-
-		OpenGL_check_error(__FILE__, __LINE__);
-	}
-
 	static void
 	apply_uniform (
 		const ShaderProgram& program, const char* name,
@@ -477,7 +564,7 @@ namespace Rays
 	static void
 	setup_texcoord_variables (
 		Matrix* matrix, Point* min, Point* max,
-		const State& state, const TextureInfo& texinfo)
+		const PainterState& state, const TextureInfo& texinfo)
 	{
 		if (!texinfo.texture) return;
 
@@ -537,7 +624,7 @@ namespace Rays
 
 		const ShaderProgram* program = Shader_get_program(batcher.shader);
 		if (!program || !*program)
-			return batcher.clear();
+			return batcher.clear_buffers();
 
 		ShaderProgram_activate(*program);
 
@@ -556,7 +643,63 @@ namespace Rays
 		self->cleanup();
 
 		ShaderProgram_deactivate();
-		batcher.clear();
+		batcher.clear_buffers();
+	}
+
+	static inline GLuint
+	get_shader_program_id (const Shader& shader)
+	{
+		const ShaderProgram* p = Shader_get_program(shader);
+		return p ? p->id() : 0;
+	}
+
+	static void
+	ensure_state_and_flush_batch (
+		Painter* painter, const Shader& shader, const Texture& texture)
+	{
+		PainterData* self     = get_data(painter);
+		Batcher&            b = self->batcher;
+		const PainterState& s = self->state;
+		GLuint  shader_id     = get_shader_program_id(shader);
+		GLuint texture_id     = Texture_get_id(texture);
+
+		bool state_changed = Xot::check_and_remove_flag(
+			&self->flags, Painter::Data::UNBATCHABLE_STATE_CHANGED);
+		if (
+			!state_changed                   &&
+			b.cached_shader_id  == shader_id &&
+			b.cached_texture_id == texture_id)
+		{
+			return;
+		}
+
+		bool blend_changed = b.blend_mode != s.blend_mode;
+		bool clip_changed  = b.clip       != s.clip;
+		if (
+			b.count > 0 &&
+			(
+				blend_changed                          ||
+				clip_changed                           ||
+				b.cached_shader_id  != shader_id       ||
+				b.cached_texture_id != texture_id      ||
+				b.texcoord_mode     != s.texcoord_mode ||
+				b.texcoord_wrap     != s.texcoord_wrap
+			))
+		{
+			Painter_flush(painter);
+		}
+
+		if (blend_changed) self->apply_blend_mode();
+		if (clip_changed)  self->apply_clipping();
+
+		b.cached_shader_id  = shader_id;
+		b.cached_texture_id = texture_id;
+		b.blend_mode        = s.blend_mode;
+		b.texcoord_mode     = s.texcoord_mode;
+		b.texcoord_wrap     = s.texcoord_wrap;
+		b.clip              = s.clip;
+		b.shader            = shader;
+		b.texture           = texture;
 	}
 
 	static inline Vector4
@@ -577,16 +720,8 @@ namespace Rays
 		PainterData* self = get_data(painter);
 		Batcher& batcher  = self->batcher;
 
-		Texture texture = texinfo ? texinfo->texture : Texture();
-		if (
-			batcher.points.empty()    ||
-			batcher.shader  != shader ||
-			batcher.texture != texture)
-		{
-			Painter_flush(painter);
-			batcher.shader  = shader;
-			batcher.texture = texture;
-		}
+		Texture texture = texinfo ? texinfo->texture : INVALID_TEXTURE;
+		ensure_state_and_flush_batch(painter, shader, texture);
 
 		if (++batcher.count <= 5)
 		{
@@ -732,7 +867,8 @@ namespace Rays
 		}
 		else
 		{
-			Painter_flush(painter);
+			ensure_state_and_flush_batch(
+				painter, *shader, texinfo ? texinfo->texture : INVALID_TEXTURE);
 			draw(
 				self, mode, color, points, npoints, indices, nindices,
 				colors, texcoords, texinfo, *shader, self->position_matrix);
@@ -781,6 +917,10 @@ namespace Rays
 	{
 		assert(painter && font && line && *line != '\0');
 
+		// exclude text rendering from batching for now;
+		// text_image is shared and gets overwritten by next text draw
+		Painter_flush(painter);
+
 		Painter::Data* self = painter->self.get();
 
 		float density          = self->pixel_density;
@@ -866,15 +1006,6 @@ namespace Rays
 
 		self->opengl_state.push();
 
-		//glEnable(GL_CULL_FACE);
-
-		glEnable(GL_DEPTH_TEST);
-		glDepthFunc(GL_LEQUAL);
-		OpenGL_check_error(__FILE__, __LINE__);
-
-		glEnable(GL_BLEND);
-		set_blend_mode(self->state.blend_mode);
-
 		FrameBuffer& fb = self->frame_buffer;
 		if (fb)
 		{
@@ -906,9 +1037,20 @@ namespace Rays
 
 		//self->position_matrix.translate(0.375f, 0.375f);
 
-		Painter_update_clip(this);
+		//glEnable(GL_CULL_FACE);
+
+		glEnable(GL_DEPTH_TEST);
+		glDepthFunc(GL_LEQUAL);
+		OpenGL_check_error(__FILE__, __LINE__);
+
+		glEnable(GL_BLEND);
+		self->apply_blend_mode();
+		self->apply_clipping();
 
-		Xot::add_flag(&self->flags, Painter::Data::PAINTING);
+		self->batcher.init(self->state);
+
+		Xot::remove_flag(&self->flags, Painter::Data::UNBATCHABLE_STATE_CHANGED);
+		Xot::   add_flag(&self->flags, Painter::Data::PAINTING);
 
 		glClear(GL_DEPTH_BUFFER_BIT);
 	}
@@ -937,6 +1079,8 @@ namespace Rays
 
 		if (self->frame_buffer)
 			FrameBuffer_unbind();
+
+		self->batcher.cleanup();
 	}
 
 	void
@@ -953,68 +1097,5 @@ namespace Rays
 		OpenGL_check_error(__FILE__, __LINE__);
 	}
 
-	void
-	Painter::set_blend_mode (BlendMode mode)
-	{
-		if (self->state.blend_mode != mode)
-			Painter_flush(this);
-
-		self->state.blend_mode = mode;
-		switch (mode)
-		{
-			case BLEND_NORMAL:
-				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
-				glBlendFuncSeparate(
-					GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE);
-				break;
-
-			case BLEND_ADD:
-				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
-				glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE, GL_ONE, GL_ONE);
-				break;
-
-			case BLEND_SUBTRACT:
-				glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_ADD);
-				glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE, GL_ONE, GL_ONE);
-				break;
-
-			case BLEND_LIGHTEST:
-				glBlendEquationSeparate(GL_MAX, GL_FUNC_ADD);
-				glBlendFuncSeparate(GL_ONE, GL_ONE, GL_ONE, GL_ONE);
-				break;
-
-			case BLEND_DARKEST:
-				glBlendEquationSeparate(GL_MIN, GL_FUNC_ADD);
-				glBlendFuncSeparate(GL_ONE, GL_ONE, GL_ONE, GL_ONE);
-				break;
-
-			case BLEND_EXCLUSION:
-				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
-				glBlendFuncSeparate(
-					GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_ONE, GL_ONE);
-				break;
-
-			case BLEND_MULTIPLY:
-				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
-				glBlendFuncSeparate(GL_ZERO, GL_SRC_COLOR, GL_ONE, GL_ONE);
-				break;
-
-			case BLEND_SCREEN:
-				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
-				glBlendFuncSeparate(GL_ONE_MINUS_DST_COLOR, GL_ONE, GL_ONE, GL_ONE);
-				break;
-
-			case BLEND_REPLACE:
-				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
-				glBlendFuncSeparate(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO);
-				break;
-
-			default:
-				argument_error(__FILE__, __LINE__, "unknown blend mode");
-				break;
-		}
-		OpenGL_check_error(__FILE__, __LINE__);
-	}
-
 
 }// Rays

data/src/painter.cpp

@@ -698,6 +698,15 @@ namespace Rays
 		return height;
 	}
 
+	void
+	Painter::set_blend_mode (BlendMode mode)
+	{
+		if (self->state.blend_mode == mode) return;
+
+		self->state.blend_mode = mode;
+		Xot::add_flag(&self->flags, Painter::Data::UNBATCHABLE_STATE_CHANGED);
+	}
+
 	BlendMode
 	Painter::blend_mode () const
 	{
@@ -716,10 +725,8 @@ namespace Rays
 		if (bounds == self->state.clip)
 			return;
 
-		Painter_flush(this);
-
 		self->state.clip = bounds;
-		Painter_update_clip(this);
+		Xot::add_flag(&self->flags, Painter::Data::UNBATCHABLE_STATE_CHANGED);
 	}
 
 	void
@@ -769,9 +776,8 @@ namespace Rays
 		if (image == self->state.texture)
 			return;
 
-		Painter_flush(this);
-
 		self->state.texture = image;
+		Xot::add_flag(&self->flags, Painter::Data::UNBATCHABLE_STATE_CHANGED);
 	}
 
 	void
@@ -779,9 +785,8 @@ namespace Rays
 	{
 		if (!self->state.texture) return;
 
-		Painter_flush(this);
-
 		self->state.texture = Image();
+		Xot::add_flag(&self->flags, Painter::Data::UNBATCHABLE_STATE_CHANGED);
 	}
 
 	const Image&
@@ -796,9 +801,8 @@ namespace Rays
 		if (mode == self->state.texcoord_mode)
 			return;
 
-		Painter_flush(this);
-
 		self->state.texcoord_mode = mode;
+		Xot::add_flag(&self->flags, Painter::Data::UNBATCHABLE_STATE_CHANGED);
 	}
 
 	TexCoordMode
@@ -813,9 +817,8 @@ namespace Rays
 		if (wrap == self->state.texcoord_wrap)
 			return;
 
-		Painter_flush(this);
-
 		self->state.texcoord_wrap = wrap;
+		Xot::add_flag(&self->flags, Painter::Data::UNBATCHABLE_STATE_CHANGED);
 	}
 
 	TexCoordWrap
@@ -830,9 +833,8 @@ namespace Rays
 		if (shader == self->state.shader)
 			return;
 
-		Painter_flush(this);
-
 		self->state.shader = shader;
+		Xot::add_flag(&self->flags, Painter::Data::UNBATCHABLE_STATE_CHANGED);
 	}
 
 	void
@@ -840,9 +842,8 @@ namespace Rays
 	{
 		if (!self->state.shader) return;
 
-		Painter_flush(this);
-
 		self->state.shader = Shader();
+		Xot::add_flag(&self->flags, Painter::Data::UNBATCHABLE_STATE_CHANGED);
 	}
 
 	const Shader&
@@ -863,11 +864,9 @@ namespace Rays
 		if (self->state_stack.empty())
 			invalid_state_error(__FILE__, __LINE__, "state stack underflow.");
 
-		Painter_flush(this);
-
 		self->state = self->state_stack.back();
 		self->state_stack.pop_back();
-		Painter_update_clip(this);
+		Xot::add_flag(&self->flags, Painter::Data::UNBATCHABLE_STATE_CHANGED);
 	}
 
 	void

data/src/painter.h

@@ -59,7 +59,7 @@ namespace Rays
 	};// PrimitiveMode
 
 
-	struct State
+	struct PainterState
 	{
 
 		Color background, colors[COLOR_TYPE_MAX];
@@ -82,16 +82,16 @@ namespace Rays
 
 		BlendMode blend_mode;
 
+		TexCoordMode texcoord_mode;
+
+		TexCoordWrap texcoord_wrap;
+
 		Bounds clip;
 
 		Font font;
 
 		Image texture;
 
-		TexCoordMode texcoord_mode;
-
-		TexCoordWrap texcoord_wrap;
-
 		Shader shader;
 
 		void init ()
@@ -109,11 +109,11 @@ namespace Rays
 			nsegment         = 0;
 			line_height      = -1;
 			blend_mode       = BLEND_NORMAL;
+			texcoord_mode    = TEXCOORD_IMAGE;
+			texcoord_wrap    = TEXCOORD_CLAMP;
 			clip             .reset(-1);
 			font             = get_default_font();
 			texture          = Image();
-			texcoord_mode    = TEXCOORD_IMAGE;
-			texcoord_wrap    = TEXCOORD_CLAMP;
 			shader           = Shader();
 		}
 
@@ -135,7 +135,7 @@ namespace Rays
 				return colors[FILL] || colors[STROKE];
 		}
 
-	};// State
+	};// PainterState
 
 
 	struct TextureInfo
@@ -177,7 +177,9 @@ namespace Rays
 		enum Flag
 		{
 
-			PAINTING = Xot::bit(1, Painter::FLAG_LAST)
+			PAINTING                  = Xot::bit(1, Painter::FLAG_LAST),
+
+			UNBATCHABLE_STATE_CHANGED = Xot::bit(2, Painter::FLAG_LAST),
 
 		};// Flag
 
@@ -187,9 +189,9 @@ namespace Rays
 
 		Bounds viewport;
 
-		State              state;
+		PainterState              state;
 
-		std::vector<State> state_stack;
+		std::vector<PainterState> state_stack;
 
 		Matrix              position_matrix;
 
@@ -214,8 +216,6 @@ namespace Rays
 	};// Painter::Data
 
 
-	void Painter_update_clip (Painter* painter);
-
 	void Painter_flush (Painter* painter);
 
 	void Painter_draw (

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rays
 version: !ruby/object:Gem::Version
-  version: 0.3.12
+  version: 0.3.13
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-09 00:00:00.000000000 Z
+date: 2026-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.12
+        version: 0.3.13
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.12
+        version: 0.3.13
 - !ruby/object:Gem::Dependency
   name: rucy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.12
+        version: 0.3.13
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.12
+        version: 0.3.13
 description: This library helps you to develop graphics application with OpenGL.
 email: xordog@gmail.com
 executables: []