From c12df73883f626344cee7f3f0497ec75b95f5e1d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lo=C3=AFc=20Hoguin?= Date: Thu, 15 Feb 2018 18:39:45 +0100 Subject: Add the glyph rendering functions --- README.asciidoc | 3 -- c_src/esdl2.h | 3 ++ c_src/sdl_ttf.c | 139 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/esdl2.erl | 12 +++++ src/sdl_ttf.erl | 21 ++++++--- 5 files changed, 169 insertions(+), 9 deletions(-) diff --git a/README.asciidoc b/README.asciidoc index 6ff2b74..dc0c915 100644 --- a/README.asciidoc +++ b/README.asciidoc @@ -94,9 +94,6 @@ to the public headers. ** `TTF_Linked_Version` (if it makes sense, depends on how the library is loaded) ** `TTF_OpenFontRW` (unclear if we need it) ** `TTF_OpenFontIndexRW` (unclear if we need it) -** `TTF_RenderGlyph_Solid` -** `TTF_RenderGlyph_Shaded` -** `TTF_RenderGlyph_Blended` * 'SDL_version.h': `SDL_GetRevisionNumber` must be implemented. The macros may also be useful. * 'SDL_video.h': The following elements are missing: ** `SDL_WINDOWPOS_*` values for different displays diff --git a/c_src/esdl2.h b/c_src/esdl2.h index 60835a7..edb104e 100644 --- a/c_src/esdl2.h +++ b/c_src/esdl2.h @@ -449,6 +449,9 @@ F(ttf_open_font, 2) \ F(ttf_open_font_index, 3) \ F(ttf_quit, 0) \ + F(ttf_render_glyph_blended, 3) \ + F(ttf_render_glyph_shaded, 4) \ + F(ttf_render_glyph_solid, 3) \ F(ttf_render_utf8_blended, 3) \ F(ttf_render_utf8_blended_wrapped, 4) \ F(ttf_render_utf8_shaded, 4) \ diff --git a/c_src/sdl_ttf.c b/c_src/sdl_ttf.c index ccde11c..4f4bed9 100644 --- a/c_src/sdl_ttf.c +++ b/c_src/sdl_ttf.c @@ -475,6 +475,145 @@ NIF_FUNCTION(ttf_quit) return nif_thread_cast(env, thread_ttf_quit, 0); } +// ttf_render_glyph_blended + +NIF_CALL_HANDLER(thread_ttf_render_glyph_blended) +{ + SDL_Surface* surface; + obj_Surface* res; + ERL_NIF_TERM term; + + surface = TTF_RenderGlyph_Blended(args[0], (long)args[1], *(SDL_Color*)args[2]); + + enif_free(args[2]); + + if (!surface) + return sdl_error_tuple(env); + + NIF_RES_TO_PTR_AND_TERM(Surface, surface, res, term); + + return enif_make_tuple2(env, + atom_ok, + term + ); +} + +NIF_FUNCTION(ttf_render_glyph_blended) +{ + void* font_res; + unsigned int ch; + SDL_Color* fg; + + BADARG_IF(!enif_get_resource(env, argv[0], res_Font, &font_res)); + BADARG_IF(!enif_get_uint(env, argv[1], &ch)); + + fg = enif_alloc(sizeof(SDL_Color)); + if (!map_to_color(env, argv[2], fg)) { + enif_free(fg); + + return enif_make_badarg(env); + } + + return nif_thread_call(env, thread_ttf_render_glyph_blended, 3, + NIF_RES_GET(Font, font_res), ch, fg); +} + +// ttf_render_glyph_shaded + +NIF_CALL_HANDLER(thread_ttf_render_glyph_shaded) +{ + SDL_Surface* surface; + obj_Surface* res; + ERL_NIF_TERM term; + + surface = TTF_RenderGlyph_Shaded(args[0], (long)args[1], + *(SDL_Color*)args[2], *(SDL_Color*)args[3]); + + enif_free(args[2]); + enif_free(args[3]); + + if (!surface) + return sdl_error_tuple(env); + + NIF_RES_TO_PTR_AND_TERM(Surface, surface, res, term); + + return enif_make_tuple2(env, + atom_ok, + term + ); +} + +NIF_FUNCTION(ttf_render_glyph_shaded) +{ + void* font_res; + unsigned int ch; + SDL_Color *fg, *bg; + + BADARG_IF(!enif_get_resource(env, argv[0], res_Font, &font_res)); + BADARG_IF(!enif_get_uint(env, argv[1], &ch)); + + fg = enif_alloc(sizeof(SDL_Color)); + if (!map_to_color(env, argv[2], fg)) { + enif_free(fg); + + return enif_make_badarg(env); + } + + bg = enif_alloc(sizeof(SDL_Color)); + if (!map_to_color(env, argv[3], bg)) { + enif_free(fg); + enif_free(bg); + + return enif_make_badarg(env); + } + + return nif_thread_call(env, thread_ttf_render_glyph_shaded, 4, + NIF_RES_GET(Font, font_res), ch, fg, bg); +} + +// ttf_render_glyph_solid + +NIF_CALL_HANDLER(thread_ttf_render_glyph_solid) +{ + SDL_Surface* surface; + obj_Surface* res; + ERL_NIF_TERM term; + + surface = TTF_RenderGlyph_Solid(args[0], (long)args[1], *(SDL_Color*)args[2]); + + enif_free(args[2]); + + if (!surface) + return sdl_error_tuple(env); + + NIF_RES_TO_PTR_AND_TERM(Surface, surface, res, term); + + return enif_make_tuple2(env, + atom_ok, + term + ); +} + +NIF_FUNCTION(ttf_render_glyph_solid) +{ + void* font_res; + unsigned int ch; + SDL_Color* fg; + + BADARG_IF(!enif_get_resource(env, argv[0], res_Font, &font_res)); + BADARG_IF(!enif_get_uint(env, argv[1], &ch)); + + fg = enif_alloc(sizeof(SDL_Color)); + if (!map_to_color(env, argv[2], fg)) { + enif_free(fg); + + return enif_make_badarg(env); + } + + return nif_thread_call(env, thread_ttf_render_glyph_solid, 3, + NIF_RES_GET(Font, font_res), ch, fg); +} + // ttf_render_utf8_blended NIF_CALL_HANDLER(thread_ttf_render_utf8_blended) diff --git a/src/esdl2.erl b/src/esdl2.erl index a5c901e..6d3c2d0 100644 --- a/src/esdl2.erl +++ b/src/esdl2.erl @@ -192,6 +192,9 @@ -export([ttf_open_font/2]). -export([ttf_open_font_index/3]). -export([ttf_quit/0]). +-export([ttf_render_glyph_blended/3]). +-export([ttf_render_glyph_shaded/4]). +-export([ttf_render_glyph_solid/3]). -export([ttf_render_utf8_blended/3]). -export([ttf_render_utf8_blended_wrapped/4]). -export([ttf_render_utf8_shaded/4]). @@ -742,6 +745,15 @@ ttf_open_font_index(_, _, _) -> ttf_quit() -> erlang:nif_error({not_loaded, ?MODULE}). +ttf_render_glyph_blended(_, _, _) -> + erlang:nif_error({not_loaded, ?MODULE}). + +ttf_render_glyph_shaded(_, _, _, _) -> + erlang:nif_error({not_loaded, ?MODULE}). + +ttf_render_glyph_solid(_, _, _) -> + erlang:nif_error({not_loaded, ?MODULE}). + ttf_render_utf8_blended(_, _, _) -> erlang:nif_error({not_loaded, ?MODULE}). diff --git a/src/sdl_ttf.erl b/src/sdl_ttf.erl index acacdcd..598acd8 100644 --- a/src/sdl_ttf.erl +++ b/src/sdl_ttf.erl @@ -158,10 +158,13 @@ open_font(Filename, PointSize, Index) -> esdl2:ttf_open_font_index(Filename, PointSize, Index), receive {'_nif_thread_ret_', Ret} -> Ret end. --spec render_blended(font(), binary(), sdl_pixels:color()) +-spec render_blended(font(), binary() | glyph(), sdl_pixels:color()) -> {ok, sdl_surface:surface()} | sdl:error(). -render_blended(Font, Text, Fg) -> +render_blended(Font, Text, Fg) when is_binary(Text) -> esdl2:ttf_render_utf8_blended(Font, Text, Fg), + receive {'_nif_thread_ret_', Ret} -> Ret end; +render_blended(Font, Glyph, Fg) -> + esdl2:ttf_render_glyph_blended(Font, Glyph, Fg), receive {'_nif_thread_ret_', Ret} -> Ret end. -spec render_blended(font(), binary(), sdl_pixels:color(), non_neg_integer()) @@ -170,16 +173,22 @@ render_blended(Font, Text, Fg, WrapLen) -> esdl2:ttf_render_utf8_blended_wrapped(Font, Text, Fg, WrapLen), receive {'_nif_thread_ret_', Ret} -> Ret end. --spec render_shaded(font(), binary(), sdl_pixels:color(), sdl_pixels:color()) +-spec render_shaded(font(), binary() | glyph(), sdl_pixels:color(), sdl_pixels:color()) -> {ok, sdl_surface:surface()} | sdl:error(). -render_shaded(Font, Text, Fg, Bg) -> +render_shaded(Font, Text, Fg, Bg) when is_binary(Text) -> esdl2:ttf_render_utf8_shaded(Font, Text, Fg, Bg), + receive {'_nif_thread_ret_', Ret} -> Ret end; +render_shaded(Font, Glyph, Fg, Bg) -> + esdl2:ttf_render_glyph_shaded(Font, Glyph, Fg, Bg), receive {'_nif_thread_ret_', Ret} -> Ret end. --spec render_solid(font(), binary(), sdl_pixels:color()) +-spec render_solid(font(), binary() | glyph(), sdl_pixels:color()) -> {ok, sdl_surface:surface()} | sdl:error(). -render_solid(Font, Text, Fg) -> +render_solid(Font, Text, Fg) when is_binary(Text) -> esdl2:ttf_render_utf8_solid(Font, Text, Fg), + receive {'_nif_thread_ret_', Ret} -> Ret end; +render_solid(Font, Glyph, Fg) -> + esdl2:ttf_render_glyph_solid(Font, Glyph, Fg), receive {'_nif_thread_ret_', Ret} -> Ret end. -spec render_size(font(), binary()) -- cgit v1.2.3