rpms/stb
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial package

Browse Source
This commit is contained in:
Benjamin A. Beasley 2021-08-23 09:47:37 -04:00
parent 8ecf26f28e
commit 196d0dcbcb
6 changed files with 1046 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored Normal file
View File

@ -0,0 +1 @@
/stb-3a1174060a7dd4eb652d4e6854bc4cd98c159200.tar.gz

233
1194.patch Normal file
View File

@ -0,0 +1,233 @@
From 3d401e71452d890eaf0bc50b11788cb08a6c2fed Mon Sep 17 00:00:00 2001
From: "Benjamin A. Beasley" <code@musicinmybrain.net>
Date: Tue, 17 Aug 2021 21:30:44 -0400
Subject: [PATCH] =?UTF-8?q?Fix=20undefined=20behavior=20from=20array=20?=
=?UTF-8?q?=E2=80=9Cshape-punning=E2=80=9D?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
In stb_voxel_render.h, there were three cases where a 2D array of
dimension [X][Y] was iterated as a 1D array of dimension [1][X*Y]. While
this is clever and is correct in terms of the actual memory layout, a
second index outside the corresponding dimension ([i][j], j >= Y])
actually produces undefined behavior and gives the compiler freedom to
do all sorts of terrible things.
The same thing happens in stb_tilemap_editor.h,
tests/caveview/cave_mesher.c, and tests/resample_test.cpp.
Prior to this commit, a compiler warning regarding the undefined
behavior appears on gcc 11.2.1 for at least some of these cases when the
tests are compiled with -Waggressive-loop-optimizations (included in
-Wall).
This commit fixes the undefined behavior by iterating these 2D arrays
with the conventional nested loops.
---
stb_tilemap_editor.h | 35 +++++++++++++++++++----------------
stb_voxel_render.h | 36 +++++++++++++++++++++---------------
tests/caveview/cave_mesher.c | 26 ++++++++++++++------------
tests/resample_test.cpp | 15 +++++++++------
4 files changed, 63 insertions(+), 49 deletions(-)
diff --git a/stb_tilemap_editor.h b/stb_tilemap_editor.h
index fbd3388084..0b8c2ca997 100644
--- a/stb_tilemap_editor.h
+++ b/stb_tilemap_editor.h
@@ -1066,14 +1066,15 @@ stbte_tilemap *stbte_create_map(int map_x, int map_y, int map_layers, int spacin
void stbte_set_background_tile(stbte_tilemap *tm, short id)
{
- int i;
+ int i, j;
STBTE_ASSERT(id >= -1);
// STBTE_ASSERT(id < 32768);
if (id < -1)
return;
- for (i=0; i < STBTE_MAX_TILEMAP_X * STBTE_MAX_TILEMAP_Y; ++i)
- if (tm->data[0][i][0] == -1)
- tm->data[0][i][0] = id;
+ for (i=0; i < STBTE_MAX_TILEMAP_X; ++i)
+ for (j=0; j < STBTE_MAX_TILEMAP_Y; ++j)
+ if (tm->data[i][j][0] == -1)
+ tm->data[i][j][0] = id;
tm->background_tile = id;
}
@@ -1212,18 +1213,20 @@ void stbte_set_dimensions(stbte_tilemap *tm, int map_x, int map_y)
void stbte_clear_map(stbte_tilemap *tm)
{
- int i,j;
- for (i=0; i < STBTE_MAX_TILEMAP_X * STBTE_MAX_TILEMAP_Y; ++i) {
- tm->data[0][i][0] = tm->background_tile;
- for (j=1; j < tm->num_layers; ++j)
- tm->data[0][i][j] = STBTE__NO_TILE;
- for (j=0; j < STBTE_MAX_PROPERTIES; ++j)
- tm->props[0][i][j] = 0;
- #ifdef STBTE_ALLOW_LINK
- tm->link[0][i].x = -1;
- tm->link[0][i].y = -1;
- tm->linkcount[0][i] = 0;
- #endif
+ int i,j,k;
+ for (i=0; i < STBTE_MAX_TILEMAP_X; ++i) {
+ for (j=0; j < STBTE_MAX_TILEMAP_Y; ++j) {
+ tm->data[i][j][0] = tm->background_tile;
+ for (k=1; k < tm->num_layers; ++k)
+ tm->data[i][j][k] = STBTE__NO_TILE;
+ for (k=0; k < STBTE_MAX_PROPERTIES; ++k)
+ tm->props[i][j][k] = 0;
+ #ifdef STBTE_ALLOW_LINK
+ tm->link[i][j].x = -1;
+ tm->link[i][j].y = -1;
+ tm->linkcount[i][j] = 0;
+ #endif
+ }
}
}
diff --git a/stb_voxel_render.h b/stb_voxel_render.h
index 2e7a372f83..51011091f7 100644
--- a/stb_voxel_render.h
+++ b/stb_voxel_render.h
@@ -3126,15 +3126,17 @@ static void stbvox_make_mesh_for_block_with_geo(stbvox_mesh_maker *mm, stbvox_po
stbvox_mesh_vertex vmesh[6][4];
stbvox_rotate rotate = { 0,0,0,0 };
unsigned char simple_rot = rot;
- int i;
+ int i, j;
// we only need to do this for the displayed faces, but it's easier
// to just do it up front; @OPTIMIZE check if it's faster to do it
// for visible faces only
- for (i=0; i < 6*4; ++i) {
- int vert = stbvox_vertex_selector[0][i];
- vert = stbvox_rotate_vertex[vert][rot];
- vmesh[0][i] = stbvox_vmesh_pre_vheight[0][i]
- + stbvox_geometry_vheight[geo][vert];
+ for (i=0; i < 6; ++i) {
+ for (j=0; j < 4; ++j) {
+ int vert = stbvox_vertex_selector[i][j];
+ vert = stbvox_rotate_vertex[vert][rot];
+ vmesh[i][j] = stbvox_vmesh_pre_vheight[i][j]
+ + stbvox_geometry_vheight[geo][vert];
+ }
}
basevert = stbvox_vertex_encode(pos.x, pos.y, pos.z << STBVOX_CONFIG_PRECISION_Z, 0,0);
@@ -3275,11 +3277,13 @@ static void stbvox_make_mesh_for_block_with_geo(stbvox_mesh_maker *mm, stbvox_po
// build vertex mesh
{
- int i;
- for (i=0; i < 6*4; ++i) {
- int vert = stbvox_vertex_selector[0][i];
- vmesh[0][i] = stbvox_vmesh_pre_vheight[0][i]
- + cube[vert];
+ int i, j;
+ for (i=0; i < 6; ++i) {
+ for (j=0; j < 4; ++j) {
+ int vert = stbvox_vertex_selector[i][j];
+ vmesh[i][j] = stbvox_vmesh_pre_vheight[i][j]
+ + cube[vert];
+ }
}
}
@@ -3541,10 +3545,12 @@ int stbvox_get_buffer_size_per_quad(stbvox_mesh_maker *mm, int n)
void stbvox_reset_buffers(stbvox_mesh_maker *mm)
{
- int i;
- for (i=0; i < STBVOX_MAX_MESHES*STBVOX_MAX_MESH_SLOTS; ++i) {
- mm->output_cur[0][i] = 0;
- mm->output_buffer[0][i] = 0;
+ int i, j;
+ for (i=0; i < STBVOX_MAX_MESHES; ++i) {
+ for (j=0; j < STBVOX_MAX_MESH_SLOTS; ++j) {
+ mm->output_cur[i][j] = 0;
+ mm->output_buffer[i][j] = 0;
+ }
}
}
diff --git a/tests/caveview/cave_mesher.c b/tests/caveview/cave_mesher.c
index 1f76c89812..bbf79898b6 100644
--- a/tests/caveview/cave_mesher.c
+++ b/tests/caveview/cave_mesher.c
@@ -802,7 +802,7 @@ void remap_in_place(int bt, int rm)
void mesh_init(void)
{
- int i;
+ int i, j;
chunk_cache_mutex = SDL_CreateMutex();
chunk_get_mutex = SDL_CreateMutex();
@@ -814,17 +814,19 @@ void mesh_init(void)
}
//effective_blocktype[50] = 0; // delete torches
- for (i=0; i < 6*256; ++i) {
- if (minecraft_tex1_for_blocktype[0][i] == 40)
- minecraft_color_for_blocktype[0][i] = 38 | 64; // apply to tex1
- if (minecraft_tex1_for_blocktype[0][i] == 39)
- minecraft_color_for_blocktype[0][i] = 39 | 64; // apply to tex1
- if (minecraft_tex1_for_blocktype[0][i] == 105)
- minecraft_color_for_blocktype[0][i] = 63; // emissive
- if (minecraft_tex1_for_blocktype[0][i] == 212)
- minecraft_color_for_blocktype[0][i] = 63; // emissive
- if (minecraft_tex1_for_blocktype[0][i] == 80)
- minecraft_color_for_blocktype[0][i] = 63; // emissive
+ for (i=0; i < 6; ++i) {
+ for (j=0; j < 256; ++j) {
+ if (minecraft_tex1_for_blocktype[i][j] == 40)
+ minecraft_color_for_blocktype[i][j] = 38 | 64; // apply to tex1
+ if (minecraft_tex1_for_blocktype[i][j] == 39)
+ minecraft_color_for_blocktype[i][j] = 39 | 64; // apply to tex1
+ if (minecraft_tex1_for_blocktype[i][j] == 105)
+ minecraft_color_for_blocktype[i][j] = 63; // emissive
+ if (minecraft_tex1_for_blocktype[i][j] == 212)
+ minecraft_color_for_blocktype[i][j] = 63; // emissive
+ if (minecraft_tex1_for_blocktype[i][j] == 80)
+ minecraft_color_for_blocktype[i][j] = 63; // emissive
+ }
}
for (i=0; i < 6; ++i) {
diff --git a/tests/resample_test.cpp b/tests/resample_test.cpp
index 21f874f18b..bb8ad82ef6 100644
--- a/tests/resample_test.cpp
+++ b/tests/resample_test.cpp
@@ -646,8 +646,9 @@ void verify_box(void)
resample_88(STBIR_FILTER_BOX);
- for (i=0; i < sizeof(image88); ++i)
- STBIR_ASSERT(image88[0][i] == output88[0][i]);
+ for (i=0; i < sizeof(image88) / sizeof(image88[0]); ++i)
+ for (j=0; j < sizeof(image88[0]); ++j)
+ STBIR_ASSERT(image88[i][j] == output88[i][j]);
t = 0;
for (j=0; j < 4; ++j)
@@ -685,12 +686,14 @@ void test_filters(void)
mtsrand(0);
- for (i=0; i < sizeof(image88); ++i)
- image88[0][i] = mtrand() & 255;
+ for (i=0; i < sizeof(image88) / sizeof(image88[0]); ++i)
+ for (j=0; j < sizeof(image88[0]); ++j)
+ image88[i][j] = mtrand() & 255;
verify_box();
- for (i=0; i < sizeof(image88); ++i)
- image88[0][i] = 0;
+ for (i=0; i < sizeof(image88) / sizeof(image88[0]); ++i)
+ for (j=0; j < sizeof(image88[0]); ++j)
+ image88[i][j] = 0;
image88[4][4] = 255;
verify_box();

59
1195.patch Normal file
View File

@ -0,0 +1,59 @@
From 5818c4e48a7e7d4c21aacf3cd6f1c7e12f770924 Mon Sep 17 00:00:00 2001
From: "Benjamin A. Beasley" <code@musicinmybrain.net>
Date: Wed, 18 Aug 2021 13:22:14 -0400
Subject: [PATCH] Fix misleading indentation in stb_divide.h
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
With -Wmisleading-indentation (part of -Wall), gcc 11.2.1 warns:
In file included from test_c_compilation.c:22:
../stb_divide.h: In function 'test':
../stb_divide.h:316:4: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
316 | if (show) printf("(%+11d,%+2d) ", q,r); stbdiv_check(q,r,a,b, "trunc",a);
| ^~
../stb_divide.h:316:45: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
316 | if (show) printf("(%+11d,%+2d) ", q,r); stbdiv_check(q,r,a,b, "trunc",a);
| ^~~~~~~~~~~~
../stb_divide.h:318:4: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
318 | if (show) printf("(%+11d,%+2d) ", q,r); stbdiv_check(q,r,a,b, "floor",b);
| ^~
../stb_divide.h:318:45: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
318 | if (show) printf("(%+11d,%+2d) ", q,r); stbdiv_check(q,r,a,b, "floor",b);
| ^~~~~~~~~~~~
../stb_divide.h:320:4: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
320 | if (show) printf("(%+11d,%+2d)\n", q,r); stbdiv_check(q,r,a,b, "euclidean",1);
| ^~
../stb_divide.h:320:45: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
320 | if (show) printf("(%+11d,%+2d)\n", q,r); stbdiv_check(q,r,a,b, "euclidean",1);
| ^~~~~~~~~~~~
This commit moves each call to stbdiv_check(…) to the following line to
make clear that it is unconditional and to resolve the warning.
---
stb_divide.h | 9 ++++++---
1 file changed, 6 insertions(+), 3 deletions(-)
diff --git a/stb_divide.h b/stb_divide.h
index 6a51e3f2e..4c24143c4 100644
--- a/stb_divide.h
+++ b/stb_divide.h
@@ -313,11 +313,14 @@ void test(int a, int b)
int q,r;
if (show) printf("(%+11d,%+d) | ", a,b);
q = stb_div_trunc(a,b), r = stb_mod_trunc(a,b);
- if (show) printf("(%+11d,%+2d) ", q,r); stbdiv_check(q,r,a,b, "trunc",a);
+ if (show) printf("(%+11d,%+2d) ", q,r);
+ stbdiv_check(q,r,a,b, "trunc",a);
q = stb_div_floor(a,b), r = stb_mod_floor(a,b);
- if (show) printf("(%+11d,%+2d) ", q,r); stbdiv_check(q,r,a,b, "floor",b);
+ if (show) printf("(%+11d,%+2d) ", q,r);
+ stbdiv_check(q,r,a,b, "floor",b);
q = stb_div_eucl (a,b), r = stb_mod_eucl (a,b);
- if (show) printf("(%+11d,%+2d)\n", q,r); stbdiv_check(q,r,a,b, "euclidean",1);
+ if (show) printf("(%+11d,%+2d)\n", q,r);
+ stbdiv_check(q,r,a,b, "euclidean",1);
}
void testh(int a, int b)

22
1196.patch Normal file
View File

@ -0,0 +1,22 @@
From 49c16b0c2a4efa72d0ce6ea05d3fa7d9e8fc6cba Mon Sep 17 00:00:00 2001
From: "Benjamin A. Beasley" <code@musicinmybrain.net>
Date: Thu, 19 Aug 2021 12:57:27 -0400
Subject: [PATCH] Add missing initializer braces in stb_easy_font.h
---
stb_easy_font.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/stb_easy_font.h b/stb_easy_font.h
index b66325847b..5f7511560a 100644
--- a/stb_easy_font.h
+++ b/stb_easy_font.h
@@ -202,7 +202,7 @@ static int stb_easy_font_print(float x, float y, char *text, unsigned char color
float start_x = x;
int offset = 0;
- stb_easy_font_color c = { 255,255,255,255 }; // use structure copying to avoid needing depending on memcpy()
+ stb_easy_font_color c = { { 255,255,255,255 } }; // use structure copying to avoid needing depending on memcpy()
if (color) { c.c[0] = color[0]; c.c[1] = color[1]; c.c[2] = color[2]; c.c[3] = color[3]; }
while (*text && offset < vbuf_size) {

1
sources Normal file
View File

@ -0,0 +1 @@
SHA512 (stb-3a1174060a7dd4eb652d4e6854bc4cd98c159200.tar.gz) = 282318244dd1002eeb6bff5c43d7ccbca26d001d5820018c354b8706bcd91e947056a5aafefcb922730cab5cabc05a03fb6576b6eb21ff76d54a4d71888f39fe

730
stb.spec Normal file
View File

@ -0,0 +1,730 @@
%global forgeurl https://github.com/nothings/%{name}
%global commit 3a1174060a7dd4eb652d4e6854bc4cd98c159200
# We choose not to package the “stb_include” library (stb_include.h) because it
# is so rife with old-school blithe C behavior—wanton use of strcat/strcpy into
# a fixed-length buffer that is assumed (but not proven) to be large enough for
# all possible uses, ignoring possible I/O errors (possibly leading to
# undefined behavior from reading uninitialized memory), and so on. Making it
# safe to use would mean a substantial rewrite.
#
# If a request for this library arises, this decision may be revisited, or the
# necessary rewrite may be done and offered upstream. For now, we omit the
# library and expect it will not be missed.
%bcond_with stb_include
Name: stb
# While the individual header-only libraries are versioned, the overall
# collection is not, and there are no releases. See:
# https://github.com/nothings/stb/issues/359
# https://github.com/nothings/stb/issues/1101
Version: 0
%forgemeta
Release: %autorelease -p
Summary: Single-file public domain libraries for C/C++
# See LICENSE.
License: MIT or Unlicense
# Additionally, the following are under different terms, but are not used; to
# make certain, they are removed in %%prep.
#
# - deprecated/rrsprintf.h, tests/caveview/stb_gl.h, and
# tests/caveview/win32/SDL_windows_main.c are Public Domain
# - tests/caveview/glext.h is MIT (only)
URL: %{forgeurl}
Source0: %{forgesource}
# Fix undefined behavior from array “shape-punning”
# https://github.com/nothings/stb/pull/1194
Patch0: %{forgeurl}//pull/1194.patch
# Fix misleading indentation in stb_divide.h
# https://github.com/nothings/stb/pull/1195
Patch1: %{forgeurl}//pull/1195.patch
# Trivial fix for array-in-structure initialization (missing braces warning)
# https://github.com/nothings/stb/pull/1196
Patch2: %{forgeurl}//pull/1196.patch
%global stb_c_lexer_version 0.12
%global stb_connected_components_version 0.96
%global stb_divide_version 0.94
%global stb_ds_version 0.67
%global stb_dxt_version 1.12
%global stb_easy_font_version 1.1
%global stb_herringbone_wang_tile_version 0.7
%global stb_hexwave_version 0.5
%global stb_image_version 2.27
%global stb_image_resize_version 0.97
%global stb_image_write_version 1.16
%global stb_include_version 0.2
%global stb_leakcheck_version 0.6
%global stb_perlin_version 0.5
%global stb_rect_pack_version 1.1
%global stb_sprintf_version 1.10
%global stb_textedit_version 1.14
%global stb_tilemap_editor_version 0.42
%global stb_truetype_version 1.25
%global stb_vorbis_version 1.22
%global stb_voxel_render_version 0.89
BuildRequires: gcc
BuildRequires: gcc-c++
BuildRequires: make
BuildRequires: /usr/bin/convert
# No compiled binaries are installed, so this would be empty.
%global debug_package %{nil}
%description
%{summary}.
%package devel
Summary: Development files for %{name}
# Dependent packages should prefer to BuildRequire the -static packages for the
# specific stb libraries they use.
Provides: %{name}-static = %{version}-%{release}
Requires: stb_c_lexer-devel%{?_isa} = %{stb_c_lexer_version}-%{release}
Requires: stb_c_lexer-static = %{stb_c_lexer_version}-%{release}
Requires: stb_connected_components-devel%{?_isa} = %{stb_connected_components_version}-%{release}
Requires: stb_connected_components-static = %{stb_connected_components_version}-%{release}
Requires: stb_divide-devel%{?_isa} = %{stb_divide_version}-%{release}
Requires: stb_divide-static = %{stb_divide_version}-%{release}
Requires: stb_ds-devel%{?_isa} = %{stb_ds_version}-%{release}
Requires: stb_ds-static = %{stb_ds_version}-%{release}
Requires: stb_dxt-devel%{?_isa} = %{stb_dxt_version}-%{release}
Requires: stb_dxt-static = %{stb_dxt_version}-%{release}
Requires: stb_easy_font-devel%{?_isa} = %{stb_easy_font_version}-%{release}
Requires: stb_easy_font-static = %{stb_easy_font_version}-%{release}
Requires: stb_herringbone_wang_tile-devel%{?_isa} = %{stb_herringbone_wang_tile_version}-%{release}
Requires: stb_herringbone_wang_tile-static = %{stb_herringbone_wang_tile_version}-%{release}
Requires: stb_hexwave-devel%{?_isa} = %{stb_hexwave_version}-%{release}
Requires: stb_hexwave-static = %{stb_hexwave_version}-%{release}
Requires: stb_image-devel%{?_isa} = %{stb_image_version}-%{release}
Requires: stb_image-static = %{stb_image_version}-%{release}
Requires: stb_image_resize-devel%{?_isa} = %{stb_image_resize_version}-%{release}
Requires: stb_image_resize-static = %{stb_image_resize_version}-%{release}
Requires: stb_image_write-devel%{?_isa} = %{stb_image_write_version}-%{release}
Requires: stb_image_write-static = %{stb_image_write_version}-%{release}
%if %{with stb_include}
Requires: stb_include-devel%{?_isa} = %{stb_include_version}-%{release}
Requires: stb_include-static = %{stb_include_version}-%{release}
%endif
Requires: stb_leakcheck-devel%{?_isa} = %{stb_leakcheck_version}-%{release}
Requires: stb_leakcheck-static = %{stb_leakcheck_version}-%{release}
Requires: stb_perlin-devel%{?_isa} = %{stb_perlin_version}-%{release}
Requires: stb_perlin-static = %{stb_perlin_version}-%{release}
Requires: stb_rect_pack-devel%{?_isa} = %{stb_rect_pack_version}-%{release}
Requires: stb_rect_pack-static = %{stb_rect_pack_version}-%{release}
Requires: stb_sprintf-devel%{?_isa} = %{stb_sprintf_version}-%{release}
Requires: stb_sprintf-static = %{stb_sprintf_version}-%{release}
Requires: stb_textedit-devel%{?_isa} = %{stb_textedit_version}-%{release}
Requires: stb_textedit-static = %{stb_textedit_version}-%{release}
Requires: stb_tilemap_editor-devel%{?_isa} = %{stb_tilemap_editor_version}-%{release}
Requires: stb_tilemap_editor-static = %{stb_tilemap_editor_version}-%{release}
Requires: stb_truetype-devel%{?_isa} = %{stb_truetype_version}-%{release}
Requires: stb_truetype-static = %{stb_truetype_version}-%{release}
Requires: stb_vorbis-devel%{?_isa} = %{stb_vorbis_version}-%{release}
Requires: stb_vorbis-static = %{stb_vorbis_version}-%{release}
Requires: stb_voxel_render-devel%{?_isa} = %{stb_voxel_render_version}-%{release}
Requires: stb_voxel_render-static = %{stb_voxel_render_version}-%{release}
%description devel
The %{name}-devel package contains libraries and header files for developing
applications that use %{name}.
This is a metapackage that requires the -devel packages for all stb libraries.
%package -n stb_c_lexer-devel
Summary: Lexer for making little C-like languages with recursive-descent parsers
Version: %{stb_c_lexer_version}
Provides: stb_c_lexer-static = %{stb_c_lexer_version}-%{release}
%description -n stb_c_lexer-devel
Lexer for making little C-like languages with recursive-descent parsers.
%package -n stb_connected_components-devel
Summary: Connected components on grids
Version: %{stb_connected_components_version}
Provides: stb_connected_components-static = %{stb_connected_components_version}-%{release}
%description -n stb_connected_components-devel
Finds connected components on 2D grids for testing reachability between two
points, with fast updates when changing reachability (e.g. on one machine it
was typically 0.2ms w/ 1024x1024 grid). Each grid square must be “open” or
“closed” (traversable or untraversable), and grid squares are only connected to
their orthogonal neighbors, not diagonally.
%package -n stb_divide-devel
Summary: Three kinds of divide/modulus of signed integers
Version: %{stb_divide_version}
Provides: stb_divide-static = %{stb_divide_version}-%{release}
%description -n stb_divide-devel
Three kinds of divide/modulus of signed integers.
%package -n stb_ds-devel
Summary: Data structures
Version: %{stb_ds_version}
Provides: stb_ds-static = %{stb_ds_version}-%{release}
%description -n stb_ds-devel
This is a single-header-file library that provides easy-to-use dynamic arrays
and hash tables for C (also works in C++).
For a gentle introduction:
http://nothings.org/stb_ds
%package -n stb_dxt-devel
Summary: DXT1/DXT5 compressor
Version: %{stb_dxt_version}
Provides: stb_dxt-static = %{stb_dxt_version}-%{release}
%description -n stb_dxt-devel
DXT1/DXT5 compressor.
%package -n stb_easy_font-devel
Summary: Bitmap font for 3D rendering
Version: %{stb_easy_font_version}
Provides: stb_easy_font-static = %{stb_easy_font_version}-%{release}
%description -n stb_easy_font-devel
Easy-to-deploy,
reasonably compact,
extremely inefficient performance-wise,
crappy-looking,
ASCII-only,
bitmap font for use in 3D APIs.
Intended for when you just want to get some text displaying in a 3D app as
quickly as possible.
Doesn’t use any textures, instead builds characters out of quads.
%package -n stb_herringbone_wang_tile-devel
Summary: Herringbone Wang Tile Generator
Version: %{stb_herringbone_wang_tile_version}
Provides: stb_herringbone_wang_tile-static = %{stb_herringbone_wang_tile_version}-%{release}
%description -n stb_herringbone_wang_tile-devel
This library is an SDK for Herringbone Wang Tile generation:
http://nothings.org/gamedev/herringbone
The core design is that you use this library offline to generate a “template”
of the tiles you’ll create. You then edit those tiles, then load the created
tile image file back into this library and use it at runtime to generate
“maps”.
You cannot load arbitrary tile image files with this library; it is only
designed to load image files made from the template it created. It stores a
binary description of the tile sizes & constraints in a few pixels, and uses
those to recover the rules, rather than trying to parse the tiles themselves.
You *can* use this library to generate from arbitrary tile sets, but only by
loading the tile set and specifying the constraints explicitly yourself.
%package -n stb_hexwave-devel
Summary: A flexible anti-aliased (bandlimited) digital audio oscillator
Version: %{stb_hexwave_version}
Provides: stb_hexwave-static = %{stb_hexwave_version}-%{release}
%description -n stb_hexwave-devel
A flexible anti-aliased (bandlimited) digital audio oscillator.
This library generates waveforms of a variety of shapes made of line segments.
It does not do envelopes, LFO effects, etc.; it merely tries to solve the
problem of generating an artifact-free morphable digital waveform with a
variety of spectra, and leaves it to the user to rescale the waveform and mix
multiple voices, etc.
%package -n stb_image-devel
Summary: Image loader
Version: %{stb_image_version}
Provides: stb_image-static = %{stb_image_version}-%{release}
%description -n stb_image-devel
Image loader.
%package -n stb_image_resize-devel
Summary: Image resizing
Version: %{stb_image_resize_version}
Provides: stb_image_resize-static = %{stb_image_resize_version}-%{release}
%description -n stb_image_resize-devel
Image resizing.
Written with emphasis on usability, portability, and efficiency. (No SIMD or
threads, so it be easily outperformed by libs that use those.) Only scaling and
translation is supported, no rotations or shears. Easy API downsamples
w/Mitchell filter, upsamples w/cubic interpolation.
%package -n stb_image_write-devel
Summary: Writes out PNG/BMP/TGA/JPEG/HDR images to C stdio
Version: %{stb_image_write_version}
Provides: stb_image_write-static = %{stb_image_write_version}-%{release}
%description -n stb_image_write-devel
This header file is a library for writing images to C stdio or a callback.
The PNG output is not optimal; it is 20-50%% larger than the file written by a
decent optimizing implementation; though providing a custom zlib compress
function (see STBIW_ZLIB_COMPRESS) can mitigate that. This library is designed
for source code compactness and simplicity, not optimal image file size or
run-time performance.
%if %{with stb_include}
%package -n stb_include-devel
Summary: Parse and process #include directives
Version: %{stb_include_version}
Provides: stb_include-static = %{stb_include_version}-%{release}
%description -n stb_include-devel
This program parses a string and replaces lines of the form
#include "foo"
with the contents of a file named "foo". It also embeds the appropriate #line
directives. Note that all include files must reside in the location specified
in the path passed to the API; it does not check multiple directories.
If the string contains a line of the form
#inject
then it will be replaced with the contents of the string ‘inject’ passed to the
API.
%endif
%package -n stb_leakcheck-devel
Summary: Quick and dirty malloc leak-checking
Version: %{stb_leakcheck_version}
Provides: stb_leakcheck-static = %{stb_leakcheck_version}-%{release}
%description -n stb_leakcheck-devel
Quick and dirty malloc leak-checking.
%package -n stb_perlin-devel
Summary: Perlin noise
Version: %{stb_perlin_version}
Provides: stb_perlin-static = %{stb_perlin_version}-%{release}
%description -n stb_perlin-devel
Perlin noise.
%package -n stb_rect_pack-devel
Summary: Rectangle packing
Version: %{stb_rect_pack_version}
Provides: stb_rect_pack-static = %{stb_rect_pack_version}-%{release}
%description -n stb_rect_pack-devel
Useful for e.g. packing rectangular textures into an atlas. Does not do
rotation.
Not necessarily the awesomest packing method, but better than the totally naive
one in stb_truetype (which is primarily what this is meant to replace).
No memory allocations; uses qsort() and assert() from stdlib. Can override
those by defining STBRP_SORT and STBRP_ASSERT.
This library currently uses the Skyline Bottom-Left algorithm.
Please note: better rectangle packers are welcome! Please implement them to the
same API, but with a different init function.
%package -n stb_sprintf-devel
Summary: Implementation of snprintf()
Version: %{stb_sprintf_version}
Provides: stb_sprintf-static = %{stb_sprintf_version}-%{release}
%description -n stb_sprintf-devel
This is a full sprintf replacement that supports everything that the C runtime
sprintfs support, including float/double, 64-bit integers, hex floats, field
parameters (%%*.*d stuff), length reads backs, etc.
Why would you need this if sprintf already exists? Well, first off, it’s *much*
faster (see below). It’s also much smaller than the CRT versions
code-space-wise. We’ve also added some simple improvements that are super handy
(commas in thousands, callbacks at buffer full, for example). Finally, the
format strings for MSVC and GCC differ for 64-bit integers (among other small
things), so this lets you use the same format strings in cross platform code.
It uses the standard single file trick of being both the header file and the
source itself. If you just include it normally, you just get the header file
function definitions. To get the code, you include it from a C or C++ file and
define STB_SPRINTF_IMPLEMENTATION first.
It only uses va_args macros from the C runtime to do its work. It does cast
doubles to S64s and shifts and divides U64s, which does drag in CRT code on
most platforms.
It compiles to roughly 8K with float support, and 4K without. As a comparison,
when using MSVC static libs, calling sprintf drags in 16K.
%package -n stb_textedit-devel
Summary: Guts of a multi-line text-editing widget
Version: %{stb_textedit_version}
Provides: stb_textedit-static = %{stb_textedit_version}-%{release}
%description -n stb_textedit-devel
This C header file implements the guts of a multi-line text-editing widget; you
implement display, word-wrapping, and low-level string insertion/deletion, and
stb_textedit will map user inputs into insertions & deletions, plus updates to
the cursor position, selection state, and undo state.
It is intended for use in games and other systems that need to build their own
custom widgets and which do not have heavy text-editing requirements (this
library is not recommended for use for editing large texts, as its performance
does not scale and it has limited undo).
Non-trivial behaviors are modelled after Windows text controls.
%package -n stb_tilemap_editor-devel
Summary: Embeddable tilemap editor for C/C++
Version: %{stb_tilemap_editor_version}
Provides: stb_tilemap_editor-static = %{stb_tilemap_editor_version}-%{release}
%description -n stb_tilemap_editor-devel
Embeddable tilemap editor for C/C++.
%package -n stb_truetype-devel
Summary: Processes TrueType Files
Version: %{stb_truetype_version}
Provides: stb_truetype-static = %{stb_truetype_version}-%{release}
%description -n stb_truetype-devel
%{summary}.
=======================================================================
NO SECURITY GUARANTEE -- DO NOT USE THIS ON UNTRUSTED FONT FILES
This library does no range checking of the offsets found in the file,
meaning an attacker can use it to read arbitrary memory.
=======================================================================
This library processes TrueType files:
• parse files
• extract glyph metrics
• extract glyph shapes
• render glyphs to one-channel bitmaps with antialiasing (box filter)
• render glyphs to one-channel SDF bitmaps (signed-distance field/function)
%package -n stb_vorbis-devel
Summary: Ogg Vorbis audio decoder
Version: %{stb_vorbis_version}
Provides: stb_vorbis-static = %{stb_vorbis_version}-%{release}
%description -n stb_vorbis-devel
Ogg Vorbis audio decoder.
%package -n stb_voxel_render-devel
Summary: Helps render large-scale “voxel” worlds for games
Version: %{stb_voxel_render_version}
Provides: stb_voxel_render-static = %{stb_voxel_render_version}-%{release}
%description -n stb_voxel_render-devel
This library helps render large-scale “voxel” worlds for games, in this case,
one with blocks that can have textures and that can also be a few shapes other
than cubes.
Video introduction:
http://www.youtube.com/watch?v=2vnTtiLrV1w
Minecraft-viewer sample app (not very simple though):
http://github.com/nothings/stb/tree/master/tests/caveview
It works by creating triangle meshes. The library includes
- converter from dense 3D arrays of block info to vertex mesh
- vertex & fragment shaders for the vertex mesh
- assistance in setting up shader state
For portability, none of the library code actually accesses the 3D graphics
API. (At the moment, it’s not actually portable since the shaders are GLSL
only, but patches are welcome.)
You have to do all the caching and tracking of vertex buffers yourself.
However, you could also try making a game with a small enough world that it’s
fully loaded rather than streaming. Currently the preferred vertex format is 20
bytes per quad. There are designs to allow much more compact formats with a
slight reduction in shader features, but no roadmap for actually implementing
them.
%package doc
Summary: Documentation for %{name}
BuildArch: noarch
%description doc
Documentation for %{name}.
%prep
%forgeautosetup -p1
# Append to OS build flags rather than overriding them
#
# Instead of hard-coding C++ standard and calling the C compiler, defer to the
# default and call the C++ compiler.
#
# When upstream says CPPFLAGS, they
# mean C++ flags, i.e. CXXFLAGS, not “C PreProcessor Flags” as is common in
# autoconf-influenced projects.
sed -r -i \
-e 's/([[:alpha:]]+FLAGS[[:blank:]]*)=/\1+=/' \
-e 's/(\$\(CC\))(.*)-std=[^[:blank:]]+/\$\(CXX\)\2/' \
-e 's/CPPFLAGS/CXXFLAGS/' tests/Makefile
# Add a dummy main(); how does this one work upstream?! Note that omitting
# parameter names is a C++-ism.
echo 'int main(int, char *[]) { return 0; }' >> tests/test_cpp_compilation.cpp
# Remove any pre-compiled Windows executables
find . -type f -name '*.exe' -print -delete
# Remove some unused parts of the source tree that could contribute different
# (but acceptable) license terms if they were used—just to prove that we do not
# use them.
rm -rvf deprecated tests/caveview
%if %{without stb_include}
sed -r -i '/#include[[:blank:]]+"stb_include.h"/d' tests/test_c_compilation.c
%endif
%build
# There is no compiled code to install, since all stb libraries are
# header-only. We do need to build the tests.
%set_build_flags
%make_build -C tests
%install
# Installing a “.c” file in /usr/include is unconventional, but correct and not
# unprecedented. Any .c file in stb is meant to be #include’d and used as a
# header-only library, just as the “.h” files in the other stb libraries. The
# only difference is the file extension.
install -t '%{buildroot}%{_includedir}' -p -m 0644 -D stb_*.h stb_*.c
%if %{without stb_include}
rm -vf '%{buildroot}%{_includedir}/stb_include.h'
%endif
%check
# The tests in tests/Makefile are largely just “will it compile” tests. There
# are some other files with main routines under tests/, but they have neither
# Makefile targets nor instructions on how to build or run them or what to
# expect them to do. We don’t dig through these sources to try to guess what to
# do with them.
# We can run image_write_test and confirm the output images are valid.
rm -vf output
mkdir -p output
./tests/image_write_test
# We assume that if ImageMagick can read the output images, then they are valid.
for img in wr6x5_flip.bmp wr6x5_flip.jpg wr6x5_flip.tga wr6x5_regular.hdr \
wr6x5_regular.png wr6x5_flip.hdr wr6x5_flip.png wr6x5_regular.bmp \
wr6x5_regular.jpg wr6x5_regular.tga
do
convert "output/${img}" 'output/dummy.bmp'
done
# As a sanity check, verify that all of the subpackage version numbers appear
# in the corresponding headers.
while read -r version header
do
%{?!with_stb_include:if [ "${header}" = 'stb_include.h' ]; then continue; fi}
# The minor version may be zero-padded in the header.
grep -E "$(
echo "${version}" |
sed -r 's/([[:digit:]]+)\.([[:digit:]]+)/\\bv\1\\.0*\2\\b/'
)" "%{buildroot}%{_includedir}/${header}" >/dev/null
done <<'EOF'
%{stb_c_lexer_version} stb_c_lexer.h
%{stb_connected_components_version} stb_connected_components.h
%{stb_divide_version} stb_divide.h
%{stb_ds_version} stb_ds.h
%{stb_dxt_version} stb_dxt.h
%{stb_easy_font_version} stb_easy_font.h
%{stb_herringbone_wang_tile_version} stb_herringbone_wang_tile.h
%{stb_hexwave_version} stb_hexwave.h
%{stb_image_version} stb_image.h
%{stb_image_resize_version} stb_image_resize.h
%{stb_image_write_version} stb_image_write.h
%{stb_include_version} stb_include.h
%{stb_leakcheck_version} stb_leakcheck.h
%{stb_perlin_version} stb_perlin.h
%{stb_rect_pack_version} stb_rect_pack.h
%{stb_sprintf_version} stb_sprintf.h
%{stb_textedit_version} stb_textedit.h
%{stb_tilemap_editor_version} stb_tilemap_editor.h
%{stb_truetype_version} stb_truetype.h
%{stb_vorbis_version} stb_vorbis.c
%{stb_voxel_render_version} stb_voxel_render.h
EOF
%files devel
# Empty metapackage
%files doc
%license LICENSE
%doc docs
%doc README.md
%doc tests/tilemap_editor_integration_example.c
%files -n stb_c_lexer-devel
%license LICENSE
%{_includedir}/stb_c_lexer.h
%files -n stb_connected_components-devel
%license LICENSE
%{_includedir}/stb_connected_components.h
%files -n stb_divide-devel
%license LICENSE
%{_includedir}/stb_divide.h
%files -n stb_ds-devel
%license LICENSE
%{_includedir}/stb_ds.h
%files -n stb_dxt-devel
%license LICENSE
%{_includedir}/stb_dxt.h
%files -n stb_easy_font-devel
%license LICENSE
%{_includedir}/stb_easy_font.h
%files -n stb_herringbone_wang_tile-devel
%license LICENSE
%{_includedir}/stb_herringbone_wang_tile.h
%files -n stb_hexwave-devel
%license LICENSE
%{_includedir}/stb_hexwave.h
%files -n stb_image-devel
%license LICENSE
%{_includedir}/stb_image.h
%files -n stb_image_resize-devel
%license LICENSE
%{_includedir}/stb_image_resize.h
%files -n stb_image_write-devel
%license LICENSE
%{_includedir}/stb_image_write.h
%if %{with stb_include}
%files -n stb_include-devel
%license LICENSE
%{_includedir}/stb_include.h
%endif
%files -n stb_leakcheck-devel
%license LICENSE
%{_includedir}/stb_leakcheck.h
%files -n stb_perlin-devel
%license LICENSE
%{_includedir}/stb_perlin.h
%files -n stb_rect_pack-devel
%license LICENSE
%{_includedir}/stb_rect_pack.h
%files -n stb_sprintf-devel
%license LICENSE
%{_includedir}/stb_sprintf.h
%files -n stb_textedit-devel
%license LICENSE
%{_includedir}/stb_textedit.h
%files -n stb_tilemap_editor-devel
%license LICENSE
%{_includedir}/stb_tilemap_editor.h
%files -n stb_truetype-devel
%license LICENSE
%{_includedir}/stb_truetype.h
%files -n stb_vorbis-devel
%license LICENSE
%{_includedir}/stb_vorbis.c
%files -n stb_voxel_render-devel
%license LICENSE
%{_includedir}/stb_voxel_render.h
%changelog
%autochangelog