WebSVN – Kolibri OS – Diff – /programs/games/2048/paint.c


#include "paint.h"
 
typedef struct {
    char b;
    char g;
    char r;
} rgb;
 
struct {
    rect    area;
    rgb*    image;
} canvas = {0};
 
__u32 canvas_index(__u16 row, __u16 column) {
    return column + row * canvas.area.width;
}
 
point canvas_position(__u32 index) {
    point p = {
        .x = index % canvas.area.width,
        .y = index / canvas.area.width
    };
    return p;
}
 
void canvas_init(rect *r)
{
    canvas.area = *r;
 
    canvas_delete();
    canvas.image = malloc(r->width * r->height * sizeof(rgb));
}
 
void canvas_delete()
{
    if (canvas.image)
        free(canvas.image);
}
 
void canvas_fill(__u32 color)
{
    if (canvas.image)
    {
        __u32 i = 0;
        __u32 len = canvas.area.width * canvas.area.height;
        for (i = 0; i < len; i++)
        {
            canvas.image[i] = *((rgb*)(&color));
        }
    }
}
 
void canvas_draw_rect(rect *r, __u32 color)
{
    if (canvas.image)
    {
        __u32 row = 0;
        __u32 column = 0;
        rgb* c = (rgb*)(&color);
 
        for (row = 0; row < r->height; row++)
        {
            for (column = 0; column < (r->width); column++)
            {
                canvas.image[canvas_index(row + r->y - canvas.area.y,
                                          column + r->x - canvas.area.x)] = *c;
            }
        }
    }
}
 
void canvas_draw_text(rect* r, char* txt, __u32 len, __u32 color)
{
 
 
 
    __u32 w;
    __u32 h;
    char* mem;
 
    h = FONT_HEIGHT;
    w = len * FONT_WIDTH + len;
    mem = malloc(sizeof(__u32) * 2 + h * w * sizeof(__u32));
 
    memset(mem,0,sizeof(__u32) * 2 + h * w * sizeof(__u32));
    ((__u32*)mem)[0] = w;
    ((__u32*)mem)[1] = h;
 
     __asm__ __volatile__("int $0x40"::
                          "a"(4),
                          "b"(0),
                          "c"(color | (8 << 24)),
                          "d"((__u32)txt),
                          "S"(len),
                          "D"((__u32)(mem)));
 
    __u16 x = r->x + (r->width - (len * FONT_WIDTH + len) * 2) / 2 - canvas.area.x;
    __u16 y = r->y + (r->height - FONT_HEIGHT * 2) / 2 - canvas.area.y;
 
    int row = 0;
    int column = 0;
    __u32* __mem = (__u32*)(mem + 8);
    for (row = 0; row < h; row++)
    {
        for (column = 0; column < w; column++)
        {
            __u32 c = __mem[column + row * w];
            if (c & 0xFF000000)
            {
                canvas.image[canvas_index(row * 2 + y,column * 2 + x)] = *((rgb*)&c);
                canvas.image[canvas_index(row * 2 + y,column * 2 + 1 + x)] = *((rgb*)&c);
 
                canvas.image[canvas_index(row * 2 + 1 + y,column * 2 + x)] = *((rgb*)&c);
                canvas.image[canvas_index(row * 2 + 1 + y,column * 2 + 1 + x)] = *((rgb*)&c);
            }
        }
    }
 
    memset(mem,0,sizeof(__u32) * 2 + h * w * sizeof(__u32));
    free(mem);
}
 
void canvas_draw_value(rect* r, __u32 v, __u32 color)
{
    char buffer[16] = {0};
    __u32 length = strlen(itoa(v,buffer,10));
    canvas_draw_text(r,buffer,length,color);
}
 
void canvas_paint()
{
    if (canvas.image)
    {
        __menuet__putimage(canvas.area.x,
                           canvas.area.y,
                           canvas.area.width,
                           canvas.area.height,
                           (char*)canvas.image);
    }
}

Rev 5231	Rev 5252
1	#include "paint.h"	1	#include "paint.h"
2		2
3	typedef struct {	3	typedef struct {
4	char b;	4	char b;
5	char g;	5	char g;
6	char r;	6	char r;
7	} rgb;	7	} rgb;
8		8
9	struct {	9	struct {
10	rect area;	10	rect area;
11	rgb* image;	11	rgb* image;
12	} canvas = {0};	12	} canvas = {0};
13		13
14	__u32 canvas_index(__u16 row, __u16 column) {	14	__u32 canvas_index(__u16 row, __u16 column) {
15	return column + row * canvas.area.width;	15	return column + row * canvas.area.width;
16	}	16	}
17		17
18	point canvas_position(__u32 index) {	18	point canvas_position(__u32 index) {
19	point p = {	19	point p = {
20	.x = index % canvas.area.width,	20	.x = index % canvas.area.width,
21	.y = index / canvas.area.width	21	.y = index / canvas.area.width
22	};	22	};
23	return p;	23	return p;
24	}	24	}
25		25
26	void canvas_init(rect *r)	26	void canvas_init(rect *r)
27	{	27	{
28	canvas.area = *r;	28	canvas.area = *r;
29		29
30	canvas_delete();	30	canvas_delete();
31	canvas.image = malloc(r->width * r->height * sizeof(rgb));	31	canvas.image = malloc(r->width * r->height * sizeof(rgb));
32	}	32	}
33		33
34	void canvas_delete()	34	void canvas_delete()
35	{	35	{
36	if (canvas.image)	36	if (canvas.image)
37	free(canvas.image);	37	free(canvas.image);
38	}	38	}
39		39
40	void canvas_fill(__u32 color)	40	void canvas_fill(__u32 color)
41	{	41	{
42	if (canvas.image)	42	if (canvas.image)
43	{	43	{
44	__u32 i = 0;	44	__u32 i = 0;
45	__u32 len = canvas.area.width * canvas.area.height;	45	__u32 len = canvas.area.width * canvas.area.height;
46	for (i = 0; i < len; i++)	46	for (i = 0; i < len; i++)
47	{	47	{
48	canvas.image[i] = ((rgb)(&color));	48	canvas.image[i] = ((rgb)(&color));
49	}	49	}
50	}	50	}
51	}	51	}
52		52
53	void canvas_draw_rect(rect *r, __u32 color)	53	void canvas_draw_rect(rect *r, __u32 color)
54	{	54	{
55	if (canvas.image)	55	if (canvas.image)
56	{	56	{
57	__u32 row = 0;	57	__u32 row = 0;
58	__u32 column = 0;	58	__u32 column = 0;
59	rgb* c = (rgb*)(&color);	59	rgb* c = (rgb*)(&color);
60		60
61	for (row = 0; row < r->height; row++)	61	for (row = 0; row < r->height; row++)
62	{	62	{
63	for (column = 0; column < (r->width); column++)	63	for (column = 0; column < (r->width); column++)
64	{	64	{
65	canvas.image[canvas_index(row + r->y - canvas.area.y,	65	canvas.image[canvas_index(row + r->y - canvas.area.y,
66	column + r->x - canvas.area.x)] = *c;	66	column + r->x - canvas.area.x)] = *c;
67	}	67	}
68	}	68	}
69	}	69	}
70	}	70	}
71		71
72	void canvas_draw_text(rect* r, char* txt, __u32 len, __u32 color)	72	void canvas_draw_text(rect* r, char* txt, __u32 len, __u32 color)
73	{	73	{
74	__u16 x = r->x + (r->width - len * FONT_WIDTH - len) / 2 - canvas.area.x;	-
75	__u16 y = r->y + (r->height - FONT_HEIGHT) / 2 - canvas.area.y;	-
76		-
77	__u32 w;	74	__u32 w;
78	__u32 h;	75	__u32 h;
79	char* mem;	76	char* mem;
80		77
81	h = FONT_HEIGHT;	78	h = FONT_HEIGHT;
82	w = len * FONT_WIDTH + len;	79	w = len * FONT_WIDTH + len;
83	mem = malloc(sizeof(__u32) * 2 + h * w * sizeof(__u32));	80	mem = malloc(sizeof(__u32) * 2 + h * w * sizeof(__u32));
84		81
85	memset(mem,0,sizeof(__u32) * 2 + h * w * sizeof(__u32));	82	memset(mem,0,sizeof(__u32) * 2 + h * w * sizeof(__u32));
86	((__u32*)mem)[0] = w;	83	((__u32*)mem)[0] = w;
87	((__u32*)mem)[1] = h;	84	((__u32*)mem)[1] = h;
88		85
89	__asm__ __volatile__("int $0x40"::	86	__asm__ __volatile__("int $0x40"::
90	"a"(4),	87	"a"(4),
91	"b"(0),	88	"b"(0),
92	"c"(color \| (8 << 24)),	89	"c"(color \| (8 << 24)),
93	"d"((__u32)txt),	90	"d"((__u32)txt),
94	"S"(len),	91	"S"(len),
95	"D"((__u32)(mem)));	92	"D"((__u32)(mem)));
-		93
-		94	__u16 x = r->x + (r->width - (len * FONT_WIDTH + len) * 2) / 2 - canvas.area.x;
-		95	__u16 y = r->y + (r->height - FONT_HEIGHT * 2) / 2 - canvas.area.y;
96		96
97	int row = 0;	97	int row = 0;
98	int column = 0;	98	int column = 0;
99	__u32* __mem = (__u32*)(mem + 8);	99	__u32* __mem = (__u32*)(mem + 8);
100	for (row = 0; row < h; row++)	100	for (row = 0; row < h; row++)
101	{	101	{
102	for (column = 0; column < w; column++)	102	for (column = 0; column < w; column++)
103	{	103	{
104	__u32 c = __mem[column + row * w];	104	__u32 c = __mem[column + row * w];
105	if (c & 0xFF000000)	105	if (c & 0xFF000000)
106	{	106	{
107	canvas.image[canvas_index(row + y,column + x)] = ((rgb)&c);	107	canvas.image[canvas_index(row * 2 + y,column * 2 + x)] = ((rgb)&c);
-		108	canvas.image[canvas_index(row * 2 + y,column * 2 + 1 + x)] = ((rgb)&c);
-		109
-		110	canvas.image[canvas_index(row * 2 + 1 + y,column * 2 + x)] = ((rgb)&c);
-		111	canvas.image[canvas_index(row * 2 + 1 + y,column * 2 + 1 + x)] = ((rgb)&c);
108	}	112	}
109	}	113	}
110	}	114	}
111		115
112	memset(mem,0,sizeof(__u32) * 2 + h * w * sizeof(__u32));	116	memset(mem,0,sizeof(__u32) * 2 + h * w * sizeof(__u32));
113	free(mem);	117	free(mem);
114	}	118	}
115		119
116	void canvas_draw_value(rect* r, __u32 v, __u32 color)	120	void canvas_draw_value(rect* r, __u32 v, __u32 color)
117	{	121	{
118	char buffer[16] = {0};	122	char buffer[16] = {0};
119	__u32 length = strlen(itoa(v,buffer,10));	123	__u32 length = strlen(itoa(v,buffer,10));
120	canvas_draw_text(r,buffer,length,color);	124	canvas_draw_text(r,buffer,length,color);
121	}	125	}
122		126
123	void canvas_paint()	127	void canvas_paint()
124	{	128	{
125	if (canvas.image)	129	if (canvas.image)
126	{	130	{
127	__menuet__putimage(canvas.area.x,	131	__menuet__putimage(canvas.area.x,
128	canvas.area.y,	132	canvas.area.y,
129	canvas.area.width,	133	canvas.area.width,
130	canvas.area.height,	134	canvas.area.height,
131	(char*)canvas.image);	135	(char*)canvas.image);
132	}	136	}
133	}	137	}

Subversion Repositories Kolibri OS

(root)/programs/games/2048/paint.c – Rev 5231 → 5252