void paint_mlx(t_vec3f *a, t_gui gui)
{
int x;
int y;
int pos;
static t_bool rendered = FALSE;
x = 0;
y = 0;
if (rendered)
return (void)mlx_put_image_to_window(gui.mlx, gui.win, gui.image, 0, 0);
while (y < HEIGHT && !(x = 0))
{
while (x < WIDTH)
{
pos = (x * gui.bpp / 8) + (y * gui.sl);
gui.pixel[pos] = (unsigned char)(ft_min(1.0, (*a).z) * 255);
gui.pixel[pos + 1] = (unsigned char)(ft_min(1.0, (*a).y) * 255);
gui.pixel[pos + 2] = (unsigned char)(ft_min(1.0, (*a).x) * 255);
a++;
x++;
}
y++;
}
rendered = TRUE;
dispose_garbage();
mlx_put_image_to_window(gui.mlx, gui.win, gui.image, 0, 0);
}
int print_s(t_data *data, va_list arg)
{
int i;
char *str;
if (data->len_mod == 8)
return (print_ls(data, arg));
str = va_arg(arg, char *);
if (!str)
{
ft_printstr("(null)", data);
return (1);
}
if (data->prec != -1)
i = data->field - ft_min(ft_strlen(str), data->prec);
else
i = data->field - ft_strlen(str);
if ((data->flag & 4) != 0)
ft_printstr(str, data);
while (i-- > 0)
ft_printchar(' ', data);
if ((data->flag & 4) == 0)
ft_printstr(str, data);
return (1);
}
int *gks_ft_render(int *x, int *y, int *width, int *height,
gks_state_list_t *gkss, const char *text, int length) {
FT_Byte *rgba_bitmap = NULL;
double red, green, blue;
int tmp, size, i, j;
int color[4];
unsigned char *mono_bitmap;
mono_bitmap = gks_ft_get_bitmap(x, y, width, height, gkss, text, length);
gks_inq_rgb(gkss->txcoli, &red, &green, &blue);
color[0] = (int)(red * 255);
color[1] = (int)(green * 255);
color[2] = (int)(blue * 255);
color[3] = (int)(gkss->alpha * 255);
size = *width * *height;
rgba_bitmap = (FT_Byte *) safe_realloc(rgba_bitmap, 4 * size);
memset(rgba_bitmap, 0, 4 * size);
for (i = 0; i < size; i++) {
for (j = 0; j < 4; j++) {
tmp = rgba_bitmap[4*i + j] + color[j] * mono_bitmap[i] / 255;
rgba_bitmap[4*i + j] = (FT_Byte) ft_min(tmp, 255);
}
}
free(mono_bitmap);
return (int *) rgba_bitmap;
}
t_sq *ft_back_co(t_tet *t, t_sq *sq, t_sq *fin, int nr)
{
t_sq *f;
int i;
f = NULL;
f = (t_sq*)malloc(sizeof(t_sq));
if (f)
ft_clone(f, sq, 13);
i = 0;
while (t[i].x != -1)
{
if (ft_is_taken(f, t[i]) == 0)
{
ft_add(f, t[i]);
if (ft_back_co(t, f, fin, nr) == NULL)
return (NULL);
ft_clone(f, sq, 13);
}
i++;
}
if (nr == f->tot)
fin = ft_min(fin, f);
if (ft_end(fin->d, nr))
return (NULL);
return (f);
}
char *ft_itoa_base(int n, int base)
{
char digits[32];
unsigned int negative;
unsigned int index;
unsigned int count;
char *out;
base = ft_min(ft_max(base, 2), 16);
negative = n & SIGN_BIT_INT;
if (negative)
n = -n;
count = 0;
while (1)
{
digits[count++] = "0123456789abcdef"[n % base];
if ((n = n / base) == 0)
break ;
}
if ((out = ft_memalloc(count + 2)) == NULL)
return (NULL);
if (negative)
*out = '-';
index = negative && 1;
while (count--)
*(out + index++) = digits[count];
return (out);
}
void ft_get_tets(t_tet *tets, t_piece **pieces)
{
while (*pieces)
{
tets->max = ft_min(*pieces);
tets->blocs = CAT((*pieces));
tets->pos = 0;
tets->ident = -1;
pieces++;
tets++;
}
}
static void set_ambiant_light(t_phpa *ph, t_scene *scene, t_ray *ray,
t_color *color)
{
double dot;
t_mtx n;
n = mtx_negate(ray->dir);
dot = ft_fclamp((dot_vect(&n, &ph->normal) + scene->ambbaseimpact)
* scene->ambcoefimpact, 0, 1);
*color = rgb_new(
ft_min(scene->i_ambiant.r, ray->closest->mat->color.r) * dot
* ray->closest->mat->k_ambiant,
ft_min(scene->i_ambiant.g, ray->closest->mat->color.g) * dot
* ray->closest->mat->k_ambiant,
ft_min(scene->i_ambiant.b, ray->closest->mat->color.b) * dot
* ray->closest->mat->k_ambiant);
ph->color = color;
ph->diffuse = &color[1];
ph->specular = &color[2];
*ph->diffuse = rgb_new(0, 0, 0);
*ph->specular = rgb_new(0, 0, 0);
}
char ft_rot(char a)
{
if (a >= 65 && a <= 90)
{
return (ft_maj(a));
}
else if (a >= 97 && a <= 122)
{
return (ft_min(a));
}
else
{
return (a);
}
}
int pgcd(int a, int b)
{
int div;
int i;
div = 1;
i = 1;
while (i <= ft_min(a, b))
{
if (a % i == 0 && b % i == 0)
div = i;
i++;
}
return (div);
}
unsigned int ft_cell_search(t_grid *grid, size_t x, size_t y)
{
unsigned int res[3];
if (!grid->g[y][x].index)
return (0);
res[0] = 0;
res[1] = 0;
res[2] = 0;
if (x < (grid->width - 1))
res[0] = (grid->g[y][x + 1].index);
if (y < (grid->height - 1))
res[1] = (grid->g[y + 1][x].index);
if ((x < (grid->width - 1)) && (y < (grid->height - 1)))
res[2] = (grid->g[y + 1][x + 1].index);
return (ft_min(res, 3) + 1);
}
unsigned char *gks_ft_get_bitmap(int *x, int *y, int *width, int *height,
gks_state_list_t *gkss, const char *text,
int length) {
FT_Face face; /* font face */
FT_Vector pen; /* glyph position */
FT_BBox bb; /* bounding box */
FT_Vector bearing; /* individual glyph translation */
FT_UInt previous; /* previous glyph index */
FT_Vector spacing; /* amount of additional space between glyphs */
FT_ULong textheight; /* textheight in FreeType convention */
FT_Error error; /* error code */
FT_Matrix rotation; /* text rotation matrix */
FT_UInt size; /* number of pixels of the bitmap */
FT_String *file; /* concatenated font path */
const FT_String *font, *prefix; /* font file name and directory */
FT_UInt *unicode_string; /* unicode text string */
FT_Int halign, valign; /* alignment */
FT_Byte *mono_bitmap = NULL; /* target for rendered text */
FT_Int num_glyphs; /* number of glyphs */
FT_Vector align;
FT_Bitmap ftbitmap;
FT_UInt codepoint;
int i, textfont, dx, dy, value, pos_x, pos_y;
unsigned int j, k;
double angle;
const int windowwidth = *width;
const int direction = (gkss->txp <= 3 && gkss->txp >= 0 ? gkss->txp : 0);
const FT_Bool vertical = (direction == GKS_K_TEXT_PATH_DOWN ||
direction == GKS_K_TEXT_PATH_UP);
const FT_String *suffix_type1 = ".afm";
if (!init) gks_ft_init();
if (gkss->txal[0] != GKS_K_TEXT_HALIGN_NORMAL) {
halign = gkss->txal[0];
} else if (vertical) {
halign = GKS_K_TEXT_HALIGN_CENTER;
} else if (direction == GKS_K_TEXT_PATH_LEFT) {
halign = GKS_K_TEXT_HALIGN_RIGHT;
} else {
halign = GKS_K_TEXT_HALIGN_LEFT;
}
valign = gkss->txal[1];
if (valign != GKS_K_TEXT_VALIGN_NORMAL) {
valign = gkss->txal[1];
} else {
valign = GKS_K_TEXT_VALIGN_BASE;
}
textfont = abs(gkss->txfont);
if (textfont >= 101 && textfont <= 131)
textfont -= 100;
else if (textfont > 1 && textfont <= 32)
textfont = map[textfont - 1];
else
textfont = 9;
textfont = textfont - 1;
font = gks_font_list[textfont];
if (font_face_cache[textfont] == NULL) {
prefix = gks_getenv("GKS_FONTPATH");
if (prefix == NULL) {
prefix = gks_getenv("GRDIR");
if (prefix == NULL)
prefix = GRDIR;
}
file = (FT_String *) malloc(strlen(prefix) + 7 + strlen(font) + 4 + 1);
strcpy(file, prefix);
#ifndef _WIN32
strcat(file, "/fonts/");
#else
strcat(file, "\\FONTS\\");
#endif
strcat(file, font);
strcat(file, ".pfb");
error = FT_New_Face(library, file, 0, &face);
if (error == FT_Err_Unknown_File_Format) {
gks_perror("unknown file format: %s", file);
return NULL;
} else if (error) {
gks_perror("could not open font file: %s", file);
return NULL;
}
if (strcmp(FT_Get_X11_Font_Format(face), "Type 1") == 0) {
strcpy(file, prefix);
#ifndef _WIN32
strcat(file, "/fonts/");
#else
strcat(file, "\\FONTS\\");
#endif
strcat(file, font);
strcat(file, suffix_type1);
FT_Attach_File(face, file);
}
free(file);
font_face_cache[textfont] = face;
} else {
face = font_face_cache[textfont];
}
num_glyphs = length;
unicode_string = (FT_UInt *) malloc(length * sizeof(FT_UInt) + 1);
if (textfont + 1 == 13) {
symbol_to_unicode((FT_Bytes)text, unicode_string, num_glyphs);
} else {
utf_to_unicode((FT_Bytes)text, unicode_string, &num_glyphs);
}
textheight = nint(gkss->chh * windowwidth * 64 / caps[textfont]);
error = FT_Set_Char_Size(face, nint(textheight * gkss->chxp), textheight,
72, 72);
if (error) gks_perror("cannot set text height");
if (gkss->chup[0] != 0.0 || gkss->chup[1] != 0.0) {
angle = atan2f(gkss->chup[1], gkss->chup[0]) - M_PI / 2;
rotation.xx = nint( cosf(angle) * 0x10000L);
rotation.xy = nint(-sinf(angle) * 0x10000L);
rotation.yx = nint( sinf(angle) * 0x10000L);
rotation.yy = nint( cosf(angle) * 0x10000L);
FT_Set_Transform(face, &rotation, NULL);
} else {
FT_Set_Transform(face, NULL, NULL);
}
spacing.x = spacing.y = 0;
if (gkss->chsp != 0.0) {
error = FT_Load_Glyph(face, FT_Get_Char_Index(face, ' '),
vertical ? FT_LOAD_VERTICAL_LAYOUT : FT_LOAD_DEFAULT);
if (!error) {
spacing.x = nint(face->glyph->advance.x * gkss->chsp);
spacing.y = nint(face->glyph->advance.y * gkss->chsp);
} else {
gks_perror("cannot apply character spacing");
}
}
bb.xMin = bb.yMin = LONG_MAX;
bb.xMax = bb.yMax = LONG_MIN;
pen.x = pen.y = 0;
previous = 0;
for (i = 0; i < num_glyphs; i++) {
codepoint = unicode_string[direction == GKS_K_TEXT_PATH_LEFT ?
(num_glyphs - 1 - i) : i];
error = set_glyph(face, codepoint, &previous, &pen, vertical, &rotation,
&bearing, halign);
if (error) continue;
bb.xMin = ft_min(bb.xMin, pen.x + bearing.x);
bb.xMax = ft_max(bb.xMax, pen.x + bearing.x + 64*face->glyph->bitmap.width);
bb.yMin = ft_min(bb.yMin, pen.y + bearing.y - 64*face->glyph->bitmap.rows);
bb.yMax = ft_max(bb.yMax, pen.y + bearing.y);
if (direction == GKS_K_TEXT_PATH_DOWN) {
pen.x -= face->glyph->advance.x + spacing.x;
pen.y -= face->glyph->advance.y + spacing.y;
} else {
pen.x += face->glyph->advance.x + spacing.x;
pen.y += face->glyph->advance.y + spacing.y;
}
}
*width = (int)((bb.xMax - bb.xMin) / 64);
*height = (int)((bb.yMax - bb.yMin) / 64);
if (bb.xMax <= bb.xMin || bb.yMax <= bb.yMin) {
gks_perror("invalid bitmap size");
free(unicode_string);
return NULL;
}
size = *width * *height;
mono_bitmap = (FT_Byte *) safe_realloc(mono_bitmap, size);
memset(mono_bitmap, 0, size);
pen.x = 0;
pen.y = 0;
previous = 0;
for (i = 0; i < num_glyphs; i++) {
bearing.x = bearing.y = 0;
codepoint = unicode_string[direction == GKS_K_TEXT_PATH_LEFT ?
(num_glyphs - 1 - i) : i];
error = set_glyph(face, codepoint, &previous, &pen, vertical, &rotation,
&bearing, halign);
if (error) continue;
pos_x = ( pen.x + bearing.x - bb.xMin) / 64;
pos_y = (-pen.y - bearing.y + bb.yMax) / 64;
ftbitmap = face->glyph->bitmap;
for (j = 0; j < (unsigned int) ftbitmap.rows; j++) {
for (k = 0; k < (unsigned int) ftbitmap.width; k++) {
dx = k + pos_x;
dy = j + pos_y;
value = mono_bitmap[dy * *width + dx];
value += ftbitmap.buffer[j * ftbitmap.pitch + k];
if (value > 255) {
value = 255;
}
mono_bitmap[dy * *width + dx] = value;
}
}
if (direction == GKS_K_TEXT_PATH_DOWN) {
pen.x -= face->glyph->advance.x + spacing.x;
pen.y -= face->glyph->advance.y + spacing.y;
} else {
pen.x += face->glyph->advance.x + spacing.x;
pen.y += face->glyph->advance.y + spacing.y;
}
}
free(unicode_string);
/* Alignment */
if (direction == GKS_K_TEXT_PATH_DOWN) {
pen.x += spacing.x;
pen.y += spacing.y;
} else {
pen.x -= spacing.x;
pen.y -= spacing.y;
}
align.x = align.y = 0;
if (valign != GKS_K_TEXT_VALIGN_BASE) {
align.y = nint(gkss->chh * windowwidth * 64);
FT_Vector_Transform(&align, &rotation);
if (valign == GKS_K_TEXT_VALIGN_HALF) {
align.x = nint(0.5 * align.x);
align.y = nint(0.5 * align.y);
} else if (valign == GKS_K_TEXT_VALIGN_TOP) {
align.x = nint(1.2 * align.x);
align.y = nint(1.2 * align.y);
} else if (valign == GKS_K_TEXT_VALIGN_BOTTOM) {
align.x = nint(-0.2 * align.x);
align.y = nint(-0.2 * align.y);
}
}
if (!vertical && halign != GKS_K_TEXT_HALIGN_LEFT) {
FT_Vector right;
right.x = face->glyph->metrics.width + face->glyph->metrics.horiBearingX;
right.y = 0;
if (right.x != 0) {
FT_Vector_Transform(&right, &rotation);
}
pen.x += right.x - face->glyph->advance.x;
pen.y += right.y - face->glyph->advance.y;
if (halign == GKS_K_TEXT_HALIGN_CENTER) {
align.x += pen.x / 2;
align.y += pen.y / 2;
} else if (halign == GKS_K_TEXT_HALIGN_RIGHT) {
align.x += pen.x;
align.y += pen.y;
}
}
*x += (bb.xMin - align.x) / 64;
*y += (bb.yMin - align.y) / 64;
return mono_bitmap;
}
