public static void *stbtt__hheap_alloc(stbtt__hheap *hh, ulong size, void *userdata) { if ((hh->first_free) != null) { void *p = hh->first_free; hh->first_free = *(void **)(p); return(p); } else { if ((hh->num_remaining_in_head_chunk) == (0)) { int count = (int)((size) < (32) ? 2000 : (size) < (128) ? 800 : 100); stbtt__hheap_chunk *c = (stbtt__hheap_chunk *)(CRuntime.Malloc((ulong)((ulong)sizeof(stbtt__hheap_chunk) + size * (ulong)(count)))); if ((c) == (null)) { return(null); } c->next = hh->head; hh->head = c; hh->num_remaining_in_head_chunk = (int)(count); } --hh->num_remaining_in_head_chunk; return((sbyte *)(hh->head) + sizeof(stbtt__hheap_chunk) + size * (ulong)hh->num_remaining_in_head_chunk); } }
public static int stbi_write_hdr_core(StbiWriteContext s, int x, int y, int comp, float *data) { if ((y <= 0) || (x <= 0) || (data == null)) { return(0); } var scratch = (byte *)(CRuntime.Malloc((ulong)(x * 4))); int i; var header = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n"; var bytes = Encoding.UTF8.GetBytes(header); fixed(byte *ptr = bytes) { s.Func(s.Context, ((sbyte *)ptr), bytes.Length); } var str = string.Format("EXPOSURE= 1.0000000000000\n\n-Y {0} +X {1}\n", y, x); bytes = Encoding.UTF8.GetBytes(str); fixed(byte *ptr = bytes) { s.Func(s.Context, ((sbyte *)ptr), bytes.Length); } for (i = 0; i < y; i++) { stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp * i * x); } CRuntime.Free(scratch); return(1); }
public static int stbtt_PackFontRanges(stbtt_pack_context spc, byte *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges) { stbtt_fontinfo info = new stbtt_fontinfo(); int i = 0; int j = 0; int n = 0; int return_value = (int)(1); stbrp_rect * rects; for (i = (int)(0); (i) < (num_ranges); ++i) { for (j = (int)(0); (j) < (ranges[i].num_chars); ++j) { ranges[i].chardata_for_range[j].x0 = (ushort)(ranges[i].chardata_for_range[j].y0 = (ushort)(ranges[i].chardata_for_range[j].x1 = (ushort)(ranges[i].chardata_for_range[j].y1 = (ushort)(0)))); } } n = (int)(0); for (i = (int)(0); (i) < (num_ranges); ++i) { n += (int)(ranges[i].num_chars); } rects = (stbrp_rect *)(CRuntime.Malloc((ulong)(sizeof(stbrp_rect) * n))); if ((rects) == (null)) { return((int)(0)); } info.userdata = spc.user_allocator_context; stbtt_InitFont(info, fontdata, (int)(stbtt_GetFontOffsetForIndex(fontdata, (int)(font_index)))); n = (int)(stbtt_PackFontRangesGatherRects(spc, info, ranges, (int)(num_ranges), rects)); stbtt_PackFontRangesPackRects(spc, rects, (int)(n)); return_value = (int)(stbtt_PackFontRangesRenderIntoRects(spc, info, ranges, (int)(num_ranges), rects)); CRuntime.Free(rects); return((int)(return_value)); }
public 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) != 0 ? -scale_y : scale_y; stbtt__edge *e; int n = 0; int i = 0; int j = 0; int k = 0; int m = 0; int vsubsample = 1; n = 0; for (i = 0; (i) < (windings); ++i) { n += wcount[i]; } e = (stbtt__edge *)(CRuntime.Malloc((ulong)(sizeof(stbtt__edge) * (n + 1)))); if ((e) == (null)) { 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; int b = j; if ((p[j].y) == (p[k].y)) { continue; } e[n].invert = 0; if ((((invert) != 0) && ((p[j].y) > (p[k].y))) || ((invert == 0) && ((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 + shift_y) * vsubsample; e[n].x1 = p[b].x * scale_x + shift_x; e[n].y1 = (p[b].y * y_scale_inv + shift_y) * vsubsample; ++n; } } stbtt__sort_edges(e, n); stbtt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, userdata); CRuntime.Free(e); }
public static int stbtt_PackBegin(stbtt_pack_context spc, byte *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context) { stbrp_context *context = (stbrp_context *)(CRuntime.Malloc((ulong)(sizeof(stbrp_context)))); int num_nodes = (int)(pw - padding); stbrp_node * nodes = (stbrp_node *)(CRuntime.Malloc((ulong)(sizeof(stbrp_node) * num_nodes))); if (((context) == (null)) || ((nodes) == (null))) { if (context != (null)) { CRuntime.Free(context); } if (nodes != (null)) { CRuntime.Free(nodes); } return((int)(0)); } spc.user_allocator_context = alloc_context; spc.width = (int)(pw); spc.height = (int)(ph); spc.pixels = pixels; spc.pack_info = context; spc.nodes = nodes; spc.padding = (int)(padding); spc.stride_in_bytes = (int)(stride_in_bytes != 0 ? stride_in_bytes : pw); spc.h_oversample = (uint)(1); spc.v_oversample = (uint)(1); spc.skip_missing = (int)(0); stbrp_init_target(context, (int)(pw - padding), (int)(ph - padding), nodes, (int)(num_nodes)); if ((pixels) != null) { CRuntime.Memset(pixels, (int)(0), (ulong)(pw * ph)); } return((int)(1)); }
public 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__hheap hh = new stbtt__hheap(); stbtt__active_edge *active = (null); int y = 0; int j = 0; int i = 0; float *scanline_data = stackalloc float[129]; float *scanline; float *scanline2; if ((result->w) > (64)) { scanline = (float *)(CRuntime.Malloc((ulong)((result->w * 2 + 1) * sizeof(float)))); } else { scanline = scanline_data; } scanline2 = scanline + result->w; y = off_y; e[n].y0 = (float)(off_y + result->h) + 1; while ((j) < (result->h)) { float scan_y_top = y + 0.0f; float scan_y_bottom = y + 1.0f; stbtt__active_edge **step = &active; CRuntime.Memset(scanline, 0, (ulong)(result->w * sizeof(float))); CRuntime.Memset(scanline2, 0, (ulong)((result->w + 1) * sizeof(float))); while ((*step) != null) { stbtt__active_edge *z = *step; if (z->ey <= scan_y_top) { *step = z->next; z->direction = 0; stbtt__hheap_free(&hh, z); } else { step = &((*step)->next); } } while (e->y0 <= scan_y_bottom) { if (e->y0 != e->y1) { stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y_top, userdata); if (z != (null)) { if (((j) == (0)) && (off_y != 0)) { if ((z->ey) < (scan_y_top)) { z->ey = scan_y_top; } } z->next = active; active = z; } } ++e; } if ((active) != null) { stbtt__fill_active_edges_new(scanline, scanline2 + 1, result->w, active, scan_y_top); } { float sum = 0; for (i = 0; (i) < (result->w); ++i) { float k = 0; int m = 0; sum += scanline2[i]; k = scanline[i] + sum; k = CRuntime.Fabs(k) * 255 + 0.5f; m = ((int)(k)); if ((m) > (255)) { m = 255; } result->pixels[j * result->stride + i] = ((byte)(m)); } } step = &active; while ((*step) != null) { stbtt__active_edge *z = *step; z->fx += z->fdx; step = &((*step)->next); } ++y; ++j; } stbtt__hheap_cleanup(&hh, userdata); if (scanline != scanline_data) { CRuntime.Free(scanline); } }
public static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata) { stbtt__point *points = null; int num_points = 0; float objspace_flatness_squared = objspace_flatness * objspace_flatness; int i = 0; int n = 0; int start = 0; int pass = 0; for (i = 0; (i) < (num_verts); ++i) { if ((vertices[i].type) == (STBTT_vmove)) { ++n; } } *num_contours = n; if ((n) == (0)) { return(null); } *contour_lengths = (int *)(CRuntime.Malloc((ulong)(sizeof(int) * n))); if ((*contour_lengths) == (null)) { *num_contours = 0; return(null); } for (pass = 0; (pass) < (2); ++pass) { float x = 0; float y = 0; if ((pass) == (1)) { points = (stbtt__point *)(CRuntime.Malloc((ulong)(num_points * sizeof(stbtt__point)))); if ((points) == (null)) { goto error; } } num_points = 0; n = -1; for (i = 0; (i) < (num_verts); ++i) { switch (vertices[i].type) { case STBTT_vmove: 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; case STBTT_vcubic: stbtt__tesselate_cubic(points, &num_points, x, y, vertices[i].cx, vertices[i].cy, vertices[i].cx1, vertices[i].cy1, 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: ; CRuntime.Free(points); CRuntime.Free(*contour_lengths); *contour_lengths = null; *num_contours = 0; return(null); }
private static void *stbi__malloc(int size) { return(CRuntime.Malloc((ulong)size)); }