ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/Deliantra-Client/Client.xs
(Generate patch)

Comparing deliantra/Deliantra-Client/Client.xs (file contents):
Revision 1.41 by root, Sat Apr 15 01:52:53 2006 UTC vs.
Revision 1.207 by root, Fri Jul 20 18:19:45 2007 UTC

1#ifdef _WIN32
2# define WIN32_LEAN_AND_MEAN
3# define NTDDI_VERSION NTDDI_WIN2K // needed to get win2000 api calls
4# include <malloc.h>
5# include <windows.h>
6# include <wininet.h>
7# pragma warning(disable:4244)
8# pragma warning(disable:4761)
9#endif
10
11//#define DEBUG 1
12#if DEBUG
13# include <valgrind/memcheck.h>
14#endif
15
1#include "EXTERN.h" 16#include "EXTERN.h"
2#include "perl.h" 17#include "perl.h"
3#include "XSUB.h" 18#include "XSUB.h"
4 19
20#ifdef _WIN32
21# undef pipe
22#endif
23
24#include <assert.h>
25#include <math.h>
5#include <string.h> 26#include <string.h>
6#include <stdio.h> 27#include <stdio.h>
28#include <stdlib.h>
7 29
8#include <SDL.h> 30#include <SDL.h>
31#include <SDL_thread.h>
32#include <SDL_endian.h>
9#include <SDL_image.h> 33#include <SDL_image.h>
34#include <SDL_mixer.h>
10#include <SDL_opengl.h> 35#include <SDL_opengl.h>
11 36
37#define PANGO_ENABLE_BACKEND
38#define G_DISABLE_CAST_CHECKS
39
12#include <glib/gmacros.h> 40#include <glib/gmacros.h>
13 41
14#include <pango/pango.h> 42#include <pango/pango.h>
15#include <pango/pangofc-fontmap.h>
16#include <pango/pangoft2.h>
17 43
44#ifndef _WIN32
18#include <sys/types.h> 45# include <sys/types.h>
19#include <sys/socket.h> 46# include <sys/socket.h>
20#include <netinet/in.h> 47# include <netinet/in.h>
21#include <netinet/tcp.h> 48# include <netinet/tcp.h>
22
23#include <inttypes.h> 49# include <inttypes.h>
50#endif
51
52#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
24 53
25#define FOW_DARKNESS 32 54#define FOW_DARKNESS 32
26 55
27#define MAP_EXTEND_X 32 56#define MAP_EXTEND_X 32
28#define MAP_EXTEND_Y 512 57#define MAP_EXTEND_Y 512
29 58
30static PangoContext *context; 59#define MIN_FONT_HEIGHT 10
31static PangoFontMap *fontmap; 60
61#if 0
62# define PARACHUTE SDL_INIT_NOPARACHUTE
63#else
64# define PARACHUTE 0
65#endif
66
67static AV *texture_av;
68
69static struct
70{
71#define GL_FUNC(ptr,name) ptr name;
72#include "glfunc.h"
73#undef GL_FUNC
74} gl;
75
76static void
77gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa)
78{
79 if (gl.BlendFuncSeparate)
80 gl.BlendFuncSeparate (sa, da, saa, daa);
81 else if (gl.BlendFuncSeparateEXT)
82 gl.BlendFuncSeparateEXT (sa, da, saa, daa);
83 else
84 glBlendFunc (sa, da);
85}
86
87static GLuint
88gen_texture ()
89{
90 GLuint name;
91
92 if (AvFILL (texture_av) >= 0)
93 name = (GLuint)(size_t)av_pop (texture_av);
94 else
95 glGenTextures (1, &name);
96
97 return name;
98}
99
100static void
101del_texture (GLuint name)
102{
103 /* make a half-assed attempt at returning the memory used by the texture */
104 /* textures are frequently being reused by cfplus anyway */
105 /*glBindTexture (GL_TEXTURE_2D, name);*/
106 /*glTexImage2D (GL_TEXTURE_2D, 0, GL_ALPHA, 0, 0, 0, GL_ALPHA, GL_UNSIGNED_BYTE, 0);*/
107 av_push (texture_av, (SV *)(size_t)name);
108 glDeleteTextures (1, &name);
109}
110
111#include "texcache.c"
112
113#include "pango-font.c"
114#include "pango-fontmap.c"
115#include "pango-render.c"
116
117typedef Mix_Chunk *CFPlus__MixChunk;
118typedef Mix_Music *CFPlus__MixMusic;
119
120typedef PangoFontDescription *CFPlus__Font;
121
122static int
123shape_attr_p (PangoLayoutRun *run)
124{
125 GSList *attrs = run->item->analysis.extra_attrs;
126
127 while (attrs)
128 {
129 PangoAttribute *attr = attrs->data;
130
131 if (attr->klass->type == PANGO_ATTR_SHAPE)
132 return 1;
133
134 attrs = attrs->next;
135 }
136
137 return 0;
138}
32 139
33typedef struct cf_layout { 140typedef struct cf_layout {
34 PangoLayout *pl; 141 PangoLayout *pl;
142 float r, g, b, a; // default color for rgba mode
35 int base_height; 143 int base_height;
144 CFPlus__Font font;
36} *CFClient__Layout; 145} *CFPlus__Layout;
146
147static CFPlus__Font default_font;
148static PangoContext *opengl_context;
149static PangoFontMap *opengl_fontmap;
37 150
38static void 151static void
39substitute_func (FcPattern *pattern, gpointer data) 152substitute_func (FcPattern *pattern, gpointer data)
40{ 153{
41 FcPatternAddBool (pattern, FC_HINTING , 1); 154 FcPatternAddBool (pattern, FC_HINTING, 1);
155#ifdef FC_HINT_STYLE
156 FcPatternAddBool (pattern, FC_HINT_STYLE, FC_HINT_FULL);
157#endif
42 FcPatternAddBool (pattern, FC_AUTOHINT, 0); 158 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
43} 159}
44 160
45static void 161static void
46layout_update (CFClient__Layout self) 162layout_update_font (CFPlus__Layout self)
47{ 163{
48 /* use a random scale factor to account for unknown descenders, 0.8 works 164 /* use a random scale factor to account for unknown descenders, 0.8 works
49 * reasonably well with bitstream vera 165 * reasonably well with bitstream vera
50 */ 166 */
51 PangoFontDescription *font = pango_context_get_font_description (context); 167 PangoFontDescription *font = self->font ? self->font : default_font;
52 pango_font_description_set_absolute_size (font, self->base_height * (PANGO_SCALE * 8 / 10)); 168
169 pango_font_description_set_absolute_size (font,
170 MAX (MIN_FONT_HEIGHT, self->base_height) * (PANGO_SCALE * 8 / 10));
171
172 pango_layout_set_font_description (self->pl, font);
53} 173}
54 174
55static void 175static void
56layout_get_pixel_size (CFClient__Layout self, int *w, int *h) 176layout_get_pixel_size (CFPlus__Layout self, int *w, int *h)
57{ 177{
58 layout_update (self); 178 PangoRectangle rect;
59 179
180 // get_pixel_* wrongly rounds down
60 pango_layout_get_pixel_size (self->pl, w, h); 181 pango_layout_get_extents (self->pl, 0, &rect);
61 182
62 *w = (*w + 3) & ~3; 183 rect.width = (rect.width + PANGO_SCALE - 1) / PANGO_SCALE;
63 if (!*w) *w = 1; 184 rect.height = (rect.height + PANGO_SCALE - 1) / PANGO_SCALE;
64 if (!*h) *h = 1; 185
186 if (!rect.width) rect.width = 1;
187 if (!rect.height) rect.height = 1;
188
189 *w = rect.width;
190 *h = rect.height;
65} 191}
192
193typedef uint16_t tileid;
194typedef uint16_t faceid;
66 195
67typedef struct { 196typedef struct {
68 GLint name; 197 int name;
69 int w, h; 198 int w, h;
70 float s, t; 199 float s, t;
71 uint8_t r, g, b, a; 200 uint8_t r, g, b, a;
72} mapface; 201 tileid smoothtile;
202 uint8_t smoothlevel;
203} maptex;
73 204
74typedef struct { 205typedef struct {
206 uint32_t player;
207 tileid tile[3];
75 int16_t darkness; 208 uint16_t darkness;
76 uint16_t face[3]; 209 uint8_t stat_width, stat_hp, flags, smoothmax;
77} mapcell; 210} mapcell;
78 211
79typedef struct { 212typedef struct {
80 int32_t c0, c1; 213 int32_t c0, c1;
81 mapcell *col; 214 mapcell *col;
82} maprow; 215} maprow;
83 216
84typedef struct map { 217typedef struct map {
85 int x, y, w, h; 218 int x, y, w, h;
86 int vx, vy; 219 int ox, oy; /* offset to virtual global coordinate system */
87 int faces; 220 int faces; tileid *face2tile; // [faceid]
88 mapface *face; 221 int texs; maptex *tex; // [tileid]
89 222
90 uint32_t rows; 223 int32_t rows;
91 maprow *row; 224 maprow *row;
92} *CFClient__Map; 225} *CFPlus__Map;
93 226
94static char * 227static char *
95prepend (char *ptr, int sze, int inc) 228prepend (char *ptr, int sze, int inc)
96{ 229{
97 char *p; 230 char *p;
… …
115 248
116#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type)) 249#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
117#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type)) 250#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
118 251
119static void 252static void
253need_facenum (struct map *self, faceid face)
254{
255 while (self->faces <= face)
256 {
257 Append (tileid, self->face2tile, self->faces, self->faces);
258 self->faces *= 2;
259 }
260}
261
262static void
263need_texid (struct map *self, int texid)
264{
265 while (self->texs <= texid)
266 {
267 Append (maptex, self->tex, self->texs, self->texs);
268 self->texs *= 2;
269 }
270}
271
272static maprow *
273map_get_row (CFPlus__Map self, int y)
274{
275 if (0 > y)
276 {
277 int extend = - y + MAP_EXTEND_Y;
278 Prepend (maprow, self->row, self->rows, extend);
279
280 self->rows += extend;
281 self->y += extend;
282 y += extend;
283 }
284 else if (y >= self->rows)
285 {
286 int extend = y - self->rows + MAP_EXTEND_Y;
287 Append (maprow, self->row, self->rows, extend);
288 self->rows += extend;
289 }
290
291 return self->row + y;
292}
293
294static mapcell *
295row_get_cell (maprow *row, int x)
296{
297 if (!row->col)
298 {
299 Newz (0, row->col, MAP_EXTEND_X, mapcell);
300 row->c0 = x - MAP_EXTEND_X / 4;
301 row->c1 = row->c0 + MAP_EXTEND_X;
302 }
303
304 if (row->c0 > x)
305 {
306 int extend = row->c0 - x + MAP_EXTEND_X;
307 Prepend (mapcell, row->col, row->c1 - row->c0, extend);
308 row->c0 -= extend;
309 }
310 else if (x >= row->c1)
311 {
312 int extend = x - row->c1 + MAP_EXTEND_X;
313 Append (mapcell, row->col, row->c1 - row->c0, extend);
314 row->c1 += extend;
315 }
316
317 return row->col + (x - row->c0);
318}
319
320static mapcell *
321map_get_cell (CFPlus__Map self, int x, int y)
322{
323 return row_get_cell (map_get_row (self, y), x);
324}
325
326static void
120map_clear (CFClient__Map self) 327map_clear (CFPlus__Map self)
121{ 328{
122 int r; 329 int r;
123 330
124 for (r = 0; r < self->rows; r++) 331 for (r = 0; r < self->rows; r++)
125 Safefree (self->row[r].col); 332 Safefree (self->row[r].col);
126 333
127 Safefree (self->row); 334 Safefree (self->row);
128 335
129 self->x = 0; 336 self->x = 0;
130 self->y = 0; 337 self->y = 0;
131 self->vx = 0; 338 self->ox = 0;
132 self->vy = 0; 339 self->oy = 0;
133 self->row = 0; 340 self->row = 0;
134 self->rows = 0; 341 self->rows = 0;
135} 342}
136 343
137static void 344static void
138map_blank (CFClient__Map self, int x0, int y0, int w, int h) 345map_blank (CFPlus__Map self, int x0, int y0, int w, int h)
139{ 346{
140 int x, y; 347 int x, y;
348 maprow *row;
349 mapcell *cell;
141 350
142 for (y = y0; y < y0 + h; y++) 351 for (y = y0; y < y0 + h; y++)
143 if (y >= 0) 352 if (y >= 0)
144 { 353 {
145 if (y >= self->rows) 354 if (y >= self->rows)
146 break; 355 break;
147 356
148 maprow *row = self->row + y; 357 row = self->row + y;
149 358
150 for (x = x0; x < x0 + w; x++) 359 for (x = x0; x < x0 + w; x++)
151 if (x >= row->c0) 360 if (x >= row->c0)
152 { 361 {
153 if (x >= row->c1) 362 if (x >= row->c1)
154 break; 363 break;
155 364
156 row->col[x - row->c0].darkness = -1; 365 cell = row->col + x - row->c0;
366
367 cell->darkness = 0;
368 cell->stat_hp = 0;
369 cell->flags = 0;
370 cell->player = 0;
157 } 371 }
158 } 372 }
159} 373}
160 374
375typedef struct {
376 tileid tile;
377 uint8_t x, y, level;
378} smooth_key;
379
380static void
381smooth_or_bits (HV *hv, smooth_key *key, IV bits)
382{
383 SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1);
384
385 if (SvIOK (*sv))
386 SvIV_set (*sv, SvIVX (*sv) | bits);
387 else
388 sv_setiv (*sv, bits);
389}
390
391static void
392music_finished (void)
393{
394 SDL_UserEvent ev;
395
396 ev.type = SDL_USEREVENT;
397 ev.code = 0;
398 ev.data1 = 0;
399 ev.data2 = 0;
400
401 SDL_PushEvent ((SDL_Event *)&ev);
402}
403
404static void
405channel_finished (int channel)
406{
407 SDL_UserEvent ev;
408
409 ev.type = SDL_USEREVENT;
410 ev.code = 1;
411 ev.data1 = (void *)(long)channel;
412 ev.data2 = 0;
413
414 SDL_PushEvent ((SDL_Event *)&ev);
415}
416
417static unsigned int
418minpot (unsigned int n)
419{
420 if (!n)
421 return 0;
422
423 --n;
424
425 n |= n >> 1;
426 n |= n >> 2;
427 n |= n >> 4;
428 n |= n >> 8;
429 n |= n >> 16;
430
431 return n + 1;
432}
433
434/* SDL should provide this, really. */
435#define SDLK_MODIFIER_MIN 300
436#define SDLK_MODIFIER_MAX 314
437
438/******************************************************************************/
439
440static int
441within_widget (SV *widget, NV x, NV y)
442{
443 HV *self;
444 SV **svp;
445 NV wx, ww, wy, wh;
446
447 if (!SvROK (widget))
448 return 0;
449
450 self = (HV *)SvRV (widget);
451
452 if (SvTYPE (self) != SVt_PVHV)
453 return 0;
454
455 svp = hv_fetch (self, "y", 1, 0); wy = svp ? SvNV (*svp) : 0.;
456 if (y < wy)
457 return 0;
458
459 svp = hv_fetch (self, "h", 1, 0); wh = svp ? SvNV (*svp) : 0.;
460 if (y >= wy + wh)
461 return 0;
462
463 svp = hv_fetch (self, "x", 1, 0); wx = svp ? SvNV (*svp) : 0.;
464 if (x < wx)
465 return 0;
466
467 svp = hv_fetch (self, "w", 1, 0); ww = svp ? SvNV (*svp) : 0.;
468 if (x >= wx + ww)
469 return 0;
470
471 svp = hv_fetch (self, "can_events", sizeof ("can_events") - 1, 0);
472 if (!svp || !SvTRUE (*svp))
473 return 0;
474
475 return 1;
476}
477
161MODULE = CFClient PACKAGE = CFClient 478MODULE = CFPlus PACKAGE = CFPlus
162 479
163PROTOTYPES: ENABLE 480PROTOTYPES: ENABLE
164 481
165BOOT: 482BOOT:
166{ 483{
167 fontmap = pango_ft2_font_map_new (); 484 HV *stash = gv_stashpv ("CFPlus", 1);
485 static const struct {
486 const char *name;
487 IV iv;
488 } *civ, const_iv[] = {
489# define const_iv(name) { # name, (IV)name }
490 const_iv (SDLK_MODIFIER_MIN),
491 const_iv (SDLK_MODIFIER_MAX),
492
493 const_iv (SDL_ACTIVEEVENT),
494 const_iv (SDL_KEYDOWN),
495 const_iv (SDL_KEYUP),
496 const_iv (SDL_MOUSEMOTION),
497 const_iv (SDL_MOUSEBUTTONDOWN),
498 const_iv (SDL_MOUSEBUTTONUP),
499 const_iv (SDL_JOYAXISMOTION),
500 const_iv (SDL_JOYBALLMOTION),
501 const_iv (SDL_JOYHATMOTION),
502 const_iv (SDL_JOYBUTTONDOWN),
503 const_iv (SDL_JOYBUTTONUP),
504 const_iv (SDL_QUIT),
505 const_iv (SDL_SYSWMEVENT),
506 const_iv (SDL_EVENT_RESERVEDA),
507 const_iv (SDL_EVENT_RESERVEDB),
508 const_iv (SDL_VIDEORESIZE),
509 const_iv (SDL_VIDEOEXPOSE),
510 const_iv (SDL_USEREVENT),
511
512 const_iv (SDL_APPINPUTFOCUS),
513 const_iv (SDL_APPMOUSEFOCUS),
514 const_iv (SDL_APPACTIVE),
515
516 const_iv (SDLK_KP0),
517 const_iv (SDLK_KP1),
518 const_iv (SDLK_KP2),
519 const_iv (SDLK_KP3),
520 const_iv (SDLK_KP4),
521 const_iv (SDLK_KP5),
522 const_iv (SDLK_KP6),
523 const_iv (SDLK_KP7),
524 const_iv (SDLK_KP8),
525 const_iv (SDLK_KP9),
526 const_iv (SDLK_KP_PERIOD),
527 const_iv (SDLK_KP_DIVIDE),
528 const_iv (SDLK_KP_MULTIPLY),
529 const_iv (SDLK_KP_MINUS),
530 const_iv (SDLK_KP_PLUS),
531 const_iv (SDLK_KP_ENTER),
532 const_iv (SDLK_KP_EQUALS),
533 const_iv (SDLK_UP),
534 const_iv (SDLK_DOWN),
535 const_iv (SDLK_RIGHT),
536 const_iv (SDLK_LEFT),
537 const_iv (SDLK_INSERT),
538 const_iv (SDLK_HOME),
539 const_iv (SDLK_END),
540 const_iv (SDLK_PAGEUP),
541 const_iv (SDLK_PAGEDOWN),
542 const_iv (SDLK_F1),
543 const_iv (SDLK_F2),
544 const_iv (SDLK_F3),
545 const_iv (SDLK_F4),
546 const_iv (SDLK_F5),
547 const_iv (SDLK_F6),
548 const_iv (SDLK_F7),
549 const_iv (SDLK_F8),
550 const_iv (SDLK_F9),
551 const_iv (SDLK_F10),
552 const_iv (SDLK_F11),
553 const_iv (SDLK_F12),
554 const_iv (SDLK_F13),
555 const_iv (SDLK_F14),
556 const_iv (SDLK_F15),
557 const_iv (SDLK_NUMLOCK),
558 const_iv (SDLK_CAPSLOCK),
559 const_iv (SDLK_SCROLLOCK),
560 const_iv (SDLK_RSHIFT),
561 const_iv (SDLK_LSHIFT),
562 const_iv (SDLK_RCTRL),
563 const_iv (SDLK_LCTRL),
564 const_iv (SDLK_RALT),
565 const_iv (SDLK_LALT),
566 const_iv (SDLK_RMETA),
567 const_iv (SDLK_LMETA),
568 const_iv (SDLK_LSUPER),
569 const_iv (SDLK_RSUPER),
570 const_iv (SDLK_MODE),
571 const_iv (SDLK_COMPOSE),
572 const_iv (SDLK_HELP),
573 const_iv (SDLK_PRINT),
574 const_iv (SDLK_SYSREQ),
575 const_iv (SDLK_BREAK),
576 const_iv (SDLK_MENU),
577 const_iv (SDLK_POWER),
578 const_iv (SDLK_EURO),
579 const_iv (SDLK_UNDO),
580
581 const_iv (KMOD_NONE),
582 const_iv (KMOD_SHIFT),
583 const_iv (KMOD_LSHIFT),
584 const_iv (KMOD_RSHIFT),
585 const_iv (KMOD_CTRL),
586 const_iv (KMOD_LCTRL),
587 const_iv (KMOD_RCTRL),
588 const_iv (KMOD_ALT),
589 const_iv (KMOD_LALT),
590 const_iv (KMOD_RALT),
591 const_iv (KMOD_META),
592 const_iv (KMOD_LMETA),
593 const_iv (KMOD_RMETA),
594 const_iv (KMOD_NUM),
595 const_iv (KMOD_CAPS),
596 const_iv (KMOD_MODE),
597# undef const_iv
598 };
599
600 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
601 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
602
603 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
604 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
605}
606
607void
608weaken (SV *rv)
609 PROTOTYPE: $
610 CODE:
611 sv_rvweaken (rv);
612
613int
614in_destruct ()
615 CODE:
616 RETVAL = PL_main_cv == Nullcv;
617 OUTPUT:
618 RETVAL
619
620NV floor (NV x)
621
622NV ceil (NV x)
623
624void
625pango_init ()
626 CODE:
627{
628 opengl_fontmap = pango_opengl_font_map_new ();
168 pango_ft2_font_map_set_default_substitute ((PangoFT2FontMap *)fontmap, substitute_func, 0, 0); 629 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
169 context = pango_ft2_font_map_create_context ((PangoFT2FontMap *)fontmap); 630 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
170} 631}
632
633char *
634SDL_GetError ()
635
636int
637SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE)
638
639void
640SDL_Quit ()
641
642void
643SDL_ListModes (int rgb, int alpha)
644 PPCODE:
645{
646 SDL_Rect **m;
647
648 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
649 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
650 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
651 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
652
653 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15);
654 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE , 0);
655
656 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE , 0);
657 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
658 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
659 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
660
661 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
662#if SDL_VERSION_ATLEAST(1,2,10)
663 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
664 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
665#endif
666
667 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
668
669 if (m && m != (SDL_Rect **)-1)
670 while (*m)
671 {
672 if ((*m)->w >= 640 && (*m)->h >= 480)
673 {
674 AV *av = newAV ();
675 av_push (av, newSViv ((*m)->w));
676 av_push (av, newSViv ((*m)->h));
677 av_push (av, newSViv (rgb));
678 av_push (av, newSViv (alpha));
679 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
680 }
681
682 ++m;
683 }
684}
685
686int
687SDL_SetVideoMode (int w, int h, int rgb, int alpha, int fullscreen)
688 CODE:
689{
690 SDL_EnableUNICODE (1);
691 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
692
693 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
694 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
695 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
696 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
697
698 RETVAL = !!SDL_SetVideoMode (
699 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0)
700 );
701
702 if (RETVAL)
703 {
704 av_clear (texture_av);
705
706 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+");
707#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
708#include "glfunc.h"
709#undef GL_FUNC
710 }
711}
712 OUTPUT:
713 RETVAL
714
715void
716SDL_GL_SwapBuffers ()
717
718char *
719SDL_GetKeyName (int sym)
720
721int
722SDL_GetAppState ()
723
724void
725poll_events ()
726 PPCODE:
727{
728 SDL_Event ev;
729
730 SDL_PumpEvents ();
731 while (SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_ALLEVENTS) > 0)
732 {
733 HV *hv = newHV ();
734 hv_store (hv, "type", 4, newSViv (ev.type), 0);
735
736 switch (ev.type)
737 {
738 case SDL_KEYDOWN:
739 case SDL_KEYUP:
740 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
741 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
742 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0);
743 hv_store (hv, "cmod", 4, newSViv (SDL_GetModState ()), 0); /* current mode */
744 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
745 break;
746
747 case SDL_ACTIVEEVENT:
748 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
749 hv_store (hv, "state", 5, newSViv (ev.active.state), 0);
750 break;
751
752 case SDL_MOUSEMOTION:
753 {
754 int state = ev.motion.state;
755 int x = ev.motion.x;
756 int y = ev.motion.y;
757 int xrel = ev.motion.xrel;
758 int yrel = ev.motion.yrel;
759
760 /* do simplistic event compression */
761 while (SDL_PeepEvents (&ev, 1, SDL_PEEKEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)) > 0
762 && state == ev.motion.state)
763 {
764 xrel += ev.motion.xrel;
765 yrel += ev.motion.yrel;
766 x = ev.motion.x;
767 y = ev.motion.y;
768 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
769 }
770
771 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);
772 hv_store (hv, "state", 5, newSViv (state), 0);
773 hv_store (hv, "x", 1, newSViv (x), 0);
774 hv_store (hv, "y", 1, newSViv (y), 0);
775 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
776 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
777 }
778 break;
779
780 case SDL_MOUSEBUTTONDOWN:
781 case SDL_MOUSEBUTTONUP:
782 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);
783
784 hv_store (hv, "button", 6, newSViv (ev.button.button), 0);
785 hv_store (hv, "state", 5, newSViv (ev.button.state), 0);
786 hv_store (hv, "x", 1, newSViv (ev.button.x), 0);
787 hv_store (hv, "y", 1, newSViv (ev.button.y), 0);
788 break;
789
790 case SDL_USEREVENT:
791 hv_store (hv, "code", 4, newSViv (ev.user.code), 0);
792 hv_store (hv, "data1", 5, newSViv ((IV)ev.user.data1), 0);
793 hv_store (hv, "data2", 5, newSViv ((IV)ev.user.data2), 0);
794 break;
795 }
796
797 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("CFPlus::UI::Event", 1))));
798 }
799}
800
801int
802Mix_OpenAudio (int frequency = 48000, int format = MIX_DEFAULT_FORMAT, int channels = 1, int chunksize = 2048)
803 POSTCALL:
804 Mix_HookMusicFinished (music_finished);
805 Mix_ChannelFinished (channel_finished);
806
807void
808Mix_CloseAudio ()
809
810int
811Mix_AllocateChannels (int numchans = -1)
171 812
172void 813void
173lowdelay (int fd, int val = 1) 814lowdelay (int fd, int val = 1)
174 CODE: 815 CODE:
175 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val)); 816 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val));
176 817
177char * 818void
178gl_version () 819win32_proxy_info ()
179 CODE: 820 PPCODE:
180 RETVAL = (char *)glGetString (GL_VERSION); 821{
181 OUTPUT: 822#ifdef _WIN32
182 RETVAL 823 char buffer[2048];
824 DWORD buflen;
183 825
184char * 826 EXTEND (SP, 3);
185gl_extensions () 827
186 CODE: 828 buflen = sizeof (buffer);
187 RETVAL = (char *)glGetString (GL_EXTENSIONS); 829 if (InternetQueryOption (0, INTERNET_OPTION_PROXY, (void *)buffer, &buflen))
188 OUTPUT: 830 if (((INTERNET_PROXY_INFO *)buffer)->dwAccessType == INTERNET_OPEN_TYPE_PROXY)
189 RETVAL 831 {
832 PUSHs (newSVpv (((INTERNET_PROXY_INFO *)buffer)->lpszProxy, 0));
833
834 buflen = sizeof (buffer);
835 if (InternetQueryOption (0, INTERNET_OPTION_PROXY_USERNAME, (void *)buffer, &buflen))
836 {
837 PUSHs (newSVpv (buffer, 0));
838
839 buflen = sizeof (buffer);
840 if (InternetQueryOption (0, INTERNET_OPTION_PROXY_PASSWORD, (void *)buffer, &buflen))
841 PUSHs (newSVpv (buffer, 0));
842 }
843 }
844#endif
845}
190 846
191void 847void
192add_font (char *file) 848add_font (char *file)
193 CODE: 849 CODE:
194 FcConfigAppFontAddFile (0, (const FcChar8 *)file); /* no idea wether this is required */ 850 FcConfigAppFontAddFile (0, (const FcChar8 *)file);
195
196void
197set_font (char *file)
198 CODE:
199{
200 int count;
201 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)file, 0, 0, &count);
202 PangoFontDescription *font = pango_fc_font_description_from_pattern (pattern, 0);
203 FcPatternDestroy (pattern);
204 pango_context_set_font_description (context, font);
205}
206 851
207void 852void
208load_image_inline (SV *image_) 853load_image_inline (SV *image_)
209 ALIAS: 854 ALIAS:
210 load_image_file = 1 855 load_image_file = 1
… …
226 croak ("load_image: %s", SDL_GetError ()); 871 croak ("load_image: %s", SDL_GetError ());
227 872
228 fmt.palette = NULL; 873 fmt.palette = NULL;
229 fmt.BitsPerPixel = 32; 874 fmt.BitsPerPixel = 32;
230 fmt.BytesPerPixel = 4; 875 fmt.BytesPerPixel = 4;
876#if SDL_BYTEORDER == SDL_LIL_ENDIAN
231 fmt.Rmask = 0x000000ff; 877 fmt.Rmask = 0x000000ff;
232 fmt.Gmask = 0x0000ff00; 878 fmt.Gmask = 0x0000ff00;
233 fmt.Bmask = 0x00ff0000; 879 fmt.Bmask = 0x00ff0000;
234 fmt.Amask = 0xff000000; 880 fmt.Amask = 0xff000000;
881#else
882 fmt.Rmask = 0xff000000;
883 fmt.Gmask = 0x00ff0000;
884 fmt.Bmask = 0x0000ff00;
885 fmt.Amask = 0x000000ff;
886#endif
235 fmt.Rloss = 0; 887 fmt.Rloss = 0;
236 fmt.Gloss = 0; 888 fmt.Gloss = 0;
237 fmt.Bloss = 0; 889 fmt.Bloss = 0;
238 fmt.Aloss = 0; 890 fmt.Aloss = 0;
239 fmt.Rshift = 0; 891 fmt.Rshift = 0;
… …
245 897
246 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE); 898 surface2 = SDL_ConvertSurface (surface, &fmt, SDL_SWSURFACE);
247 899
248 assert (surface2->pitch == surface2->w * 4); 900 assert (surface2->pitch == surface2->w * 4);
249 901
902 SDL_LockSurface (surface2);
250 EXTEND (SP, 5); 903 EXTEND (SP, 6);
251 PUSHs (sv_2mortal (newSViv (surface2->w))); 904 PUSHs (sv_2mortal (newSViv (surface2->w)));
252 PUSHs (sv_2mortal (newSViv (surface2->h))); 905 PUSHs (sv_2mortal (newSViv (surface2->h)));
253 SDL_LockSurface (surface2);
254 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 906 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch)));
255 SDL_UnlockSurface (surface2);
256 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB))); 907 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));
257 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 908 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
258 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_INT_8_8_8_8_REV))); 909 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
910 SDL_UnlockSurface (surface2);
259 911
260 SDL_FreeSurface (surface); 912 SDL_FreeSurface (surface);
261 SDL_FreeSurface (surface2); 913 SDL_FreeSurface (surface2);
262} 914}
263 915
… …
285 PUSHs (sv_2mortal (newSViv (b / y))); 937 PUSHs (sv_2mortal (newSViv (b / y)));
286 PUSHs (sv_2mortal (newSViv (a / y))); 938 PUSHs (sv_2mortal (newSViv (a / y)));
287} 939}
288 940
289void 941void
942error (char *message)
943 CODE:
944 fprintf (stderr, "ERROR: %s\n", message);
945#ifdef _WIN32
946 MessageBox (0, message, "Crossfire+ Error", MB_OK | MB_ICONERROR);
947#endif
948
949void
290fatal (char *message) 950fatal (char *message)
291 CODE: 951 CODE:
952 fprintf (stderr, "FATAL: %s\n", message);
953#ifdef _WIN32
954 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR);
955#endif
956 _exit (1);
957
958void
959_exit (int retval = 0)
960 CODE:
292#ifdef WIN32 961#ifdef WIN32
293 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR | MB_SETFOREGROUND); 962 ExitThread (retval); // unclean, please beam me up
294#else 963#else
295 fprintf (stderr, "FATAL: %s\n", message); 964 _exit (retval);
296#endif 965#endif
297 exit (1);
298 966
967void
968debug ()
969 CODE:
970{
971#if DEBUG
972 VALGRIND_DO_LEAK_CHECK;
973#endif
974}
975
976MODULE = CFPlus PACKAGE = CFPlus::Font
977
978PROTOTYPES: DISABLE
979
980CFPlus::Font
981new_from_file (SV *class, char *path, int id = 0)
982 CODE:
983{
984 int count;
985 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
986 RETVAL = pango_fc_font_description_from_pattern (pattern, 0);
987 FcPatternDestroy (pattern);
988}
989 OUTPUT:
990 RETVAL
991
992void
993DESTROY (CFPlus::Font self)
994 CODE:
995 pango_font_description_free (self);
996
997void
998make_default (CFPlus::Font self)
999 PROTOTYPE: $
1000 CODE:
1001 default_font = self;
1002
299MODULE = CFClient PACKAGE = CFClient::Layout 1003MODULE = CFPlus PACKAGE = CFPlus::Layout
300 1004
301CFClient::Layout 1005PROTOTYPES: DISABLE
302new (SV *class, int base_height = 10) 1006
1007void
1008reset_glyph_cache ()
1009 PROTOTYPE:
1010 CODE:
1011 tc_clear ();
1012
1013CFPlus::Layout
1014new (SV *class)
303 CODE: 1015 CODE:
304 New (0, RETVAL, 1, struct cf_layout); 1016 New (0, RETVAL, 1, struct cf_layout);
305 RETVAL->base_height = base_height; 1017
306 RETVAL->pl = pango_layout_new (context); 1018 RETVAL->pl = pango_layout_new (opengl_context);
1019 RETVAL->r = 1.;
1020 RETVAL->g = 1.;
1021 RETVAL->b = 1.;
1022 RETVAL->a = 1.;
1023 RETVAL->base_height = MIN_FONT_HEIGHT;
1024 RETVAL->font = 0;
1025
307 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR); 1026 pango_layout_set_wrap (RETVAL->pl, PANGO_WRAP_WORD_CHAR);
1027 layout_update_font (RETVAL);
308 OUTPUT: 1028 OUTPUT:
309 RETVAL 1029 RETVAL
310 1030
311void 1031void
312DESTROY (CFClient::Layout self) 1032DESTROY (CFPlus::Layout self)
313 CODE: 1033 CODE:
314 g_object_unref (self->pl); 1034 g_object_unref (self->pl);
315 Safefree (self); 1035 Safefree (self);
316 1036
317void 1037void
318set_text (CFClient::Layout self, SV *text_) 1038set_text (CFPlus::Layout self, SV *text_)
319 CODE: 1039 CODE:
320{ 1040{
321 STRLEN textlen; 1041 STRLEN textlen;
322 char *text = SvPVutf8 (text_, textlen); 1042 char *text = SvPVutf8 (text_, textlen);
323 1043
324 pango_layout_set_text (self->pl, text, textlen); 1044 pango_layout_set_text (self->pl, text, textlen);
325} 1045}
326 1046
327void 1047void
328set_markup (CFClient::Layout self, SV *text_) 1048set_markup (CFPlus::Layout self, SV *text_)
329 CODE: 1049 CODE:
330{ 1050{
331 STRLEN textlen; 1051 STRLEN textlen;
332 char *text = SvPVutf8 (text_, textlen); 1052 char *text = SvPVutf8 (text_, textlen);
333 1053
334 pango_layout_set_markup (self->pl, text, textlen); 1054 pango_layout_set_markup (self->pl, text, textlen);
335} 1055}
336 1056
337void 1057void
1058set_shapes (CFPlus::Layout self, ...)
1059 CODE:
1060{
1061 PangoAttrList *attrs = 0;
1062 const char *text = pango_layout_get_text (self->pl);
1063 const char *pos = text;
1064 int arg = 4;
1065
1066 while (arg < items && (pos = strstr (pos, OBJ_STR)))
1067 {
1068 PangoRectangle inkrect, rect;
1069 PangoAttribute *attr;
1070
1071 int x = SvIV (ST (arg - 3));
1072 int y = SvIV (ST (arg - 2));
1073 int w = SvIV (ST (arg - 1));
1074 int h = SvIV (ST (arg ));
1075
1076 inkrect.x = 0;
1077 inkrect.y = 0;
1078 inkrect.width = 0;
1079 inkrect.height = 0;
1080
1081 rect.x = x * PANGO_SCALE;
1082 rect.y = y * PANGO_SCALE;
1083 rect.width = w * PANGO_SCALE;
1084 rect.height = h * PANGO_SCALE;
1085
1086 if (!attrs)
1087 attrs = pango_layout_get_attributes (self->pl);
1088
1089 attr = pango_attr_shape_new (&inkrect, &rect);
1090 attr->start_index = pos - text;
1091 attr->end_index = attr->start_index + sizeof (OBJ_STR) - 1;
1092 pango_attr_list_insert (attrs, attr);
1093
1094 arg += 4;
1095 pos += sizeof (OBJ_STR) - 1;
1096 }
1097
1098 if (attrs)
1099 pango_layout_set_attributes (self->pl, attrs);
1100}
1101
1102void
1103get_shapes (CFPlus::Layout self)
1104 PPCODE:
1105{
1106 PangoLayoutIter *iter = pango_layout_get_iter (self->pl);
1107
1108 do
1109 {
1110 PangoLayoutRun *run = pango_layout_iter_get_run (iter);
1111
1112 if (run && shape_attr_p (run))
1113 {
1114 PangoRectangle extents;
1115 pango_layout_iter_get_run_extents (iter, 0, &extents);
1116
1117 EXTEND (SP, 2);
1118 PUSHs (sv_2mortal (newSViv (PANGO_PIXELS (extents.x))));
1119 PUSHs (sv_2mortal (newSViv (PANGO_PIXELS (extents.y))));
1120 }
1121 }
1122 while (pango_layout_iter_next_run (iter));
1123
1124 pango_layout_iter_free (iter);
1125}
1126
1127int
1128has_wrapped (CFPlus::Layout self)
1129 CODE:
1130{
1131 int lines = 1;
1132 const char *text = pango_layout_get_text (self->pl);
1133
1134 while (*text)
1135 lines += *text++ == '\n';
1136
1137 RETVAL = lines < pango_layout_get_line_count (self->pl);
1138}
1139 OUTPUT:
1140 RETVAL
1141
1142SV *
1143get_text (CFPlus::Layout self)
1144 CODE:
1145 RETVAL = newSVpv (pango_layout_get_text (self->pl), 0);
1146 sv_utf8_decode (RETVAL);
1147 OUTPUT:
1148 RETVAL
1149
1150void
1151set_foreground (CFPlus::Layout self, float r, float g, float b, float a = 1.)
1152 CODE:
1153 self->r = r;
1154 self->g = g;
1155 self->b = b;
1156 self->a = a;
1157
1158void
1159set_font (CFPlus::Layout self, CFPlus::Font font = 0)
1160 CODE:
1161 if (self->font != font)
1162 {
1163 self->font = font;
1164 layout_update_font (self);
1165 }
1166
1167void
338set_height (CFClient::Layout self, int base_height) 1168set_height (CFPlus::Layout self, int base_height)
339 CODE: 1169 CODE:
1170 if (self->base_height != base_height)
1171 {
340 self->base_height = base_height; 1172 self->base_height = base_height;
1173 layout_update_font (self);
1174 }
341 1175
342void 1176void
343set_width (CFClient::Layout self, int max_width = -1) 1177set_width (CFPlus::Layout self, int max_width = -1)
344 CODE: 1178 CODE:
345 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE); 1179 pango_layout_set_width (self->pl, max_width < 0 ? max_width : max_width * PANGO_SCALE);
346 1180
347void 1181void
1182set_indent (CFPlus::Layout self, int indent)
1183 CODE:
1184 pango_layout_set_indent (self->pl, indent * PANGO_SCALE);
1185
1186void
1187set_spacing (CFPlus::Layout self, int spacing)
1188 CODE:
1189 pango_layout_set_spacing (self->pl, spacing * PANGO_SCALE);
1190
1191void
1192set_ellipsise (CFPlus::Layout self, int ellipsise)
1193 CODE:
1194 pango_layout_set_ellipsize (self->pl,
1195 ellipsise == 1 ? PANGO_ELLIPSIZE_START
1196 : ellipsise == 2 ? PANGO_ELLIPSIZE_MIDDLE
1197 : ellipsise == 3 ? PANGO_ELLIPSIZE_END
1198 : PANGO_ELLIPSIZE_NONE
1199 );
1200
1201void
1202set_single_paragraph_mode (CFPlus::Layout self, int spm)
1203 CODE:
1204 pango_layout_set_single_paragraph_mode (self->pl, !!spm);
1205
1206void
348size (CFClient::Layout self) 1207size (CFPlus::Layout self)
349 PPCODE: 1208 PPCODE:
350{ 1209{
351 int w, h; 1210 int w, h;
352 1211
353 layout_update (self);
354 layout_get_pixel_size (self, &w, &h); 1212 layout_get_pixel_size (self, &w, &h);
355 1213
356 EXTEND (SP, 2); 1214 EXTEND (SP, 2);
357 PUSHs (sv_2mortal (newSViv (w))); 1215 PUSHs (sv_2mortal (newSViv (w)));
358 PUSHs (sv_2mortal (newSViv (h))); 1216 PUSHs (sv_2mortal (newSViv (h)));
359} 1217}
360 1218
361int 1219int
1220descent (CFPlus::Layout self)
1221 CODE:
1222{
1223 PangoRectangle rect;
1224 PangoLayoutLine *line = pango_layout_get_line (self->pl, 0);
1225 pango_layout_line_get_pixel_extents (line, 0, &rect);
1226 RETVAL = PANGO_DESCENT (rect);
1227}
1228 OUTPUT:
1229 RETVAL
1230
1231int
362xy_to_index (CFClient::Layout self, int x, int y) 1232xy_to_index (CFPlus::Layout self, int x, int y)
363 CODE: 1233 CODE:
364{ 1234{
365 int index, trailing; 1235 int index, trailing;
366
367 layout_update (self);
368 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing); 1236 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing);
369
370 RETVAL = index; 1237 RETVAL = index + trailing;
371} 1238}
372 OUTPUT: 1239 OUTPUT:
373 RETVAL 1240 RETVAL
374 1241
375void 1242void
376cursor_pos (CFClient::Layout self, int index) 1243cursor_pos (CFPlus::Layout self, int index)
377 PPCODE: 1244 PPCODE:
378{ 1245{
379 PangoRectangle strong_pos; 1246 PangoRectangle strong_pos;
380 layout_update (self);
381 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0); 1247 pango_layout_get_cursor_pos (self->pl, index, &strong_pos, 0);
382 1248
383 EXTEND (SP, 3); 1249 EXTEND (SP, 3);
384 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1250 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));
385 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1251 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
386 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1252 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE)));
387} 1253}
388 1254
389void 1255void
390render (CFClient::Layout self) 1256index_to_line_x (CFPlus::Layout self, int index, int trailing = 0)
391 PPCODE: 1257 PPCODE:
392{ 1258{
393 SV *retval; 1259 int line, x;
394 int w, h;
395 FT_Bitmap bitmap;
396 1260
397 layout_update (self); 1261 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
398 layout_get_pixel_size (self, &w, &h); 1262 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
399 1263
400 retval = newSV (w * h);
401 SvPOK_only (retval);
402 SvCUR_set (retval, w * h);
403
404 bitmap.rows = h;
405 bitmap.width = w;
406 bitmap.pitch = w;
407 bitmap.buffer = (unsigned char*)SvPVX (retval);
408 bitmap.num_grays = 256;
409 bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
410
411 memset (bitmap.buffer, 0, w * h);
412
413 pango_ft2_render_layout (&bitmap, self->pl, 0 * PANGO_SCALE, 0 * PANGO_SCALE);
414
415 EXTEND (SP, 3); 1264 EXTEND (SP, 2);
416 PUSHs (sv_2mortal (newSViv (w))); 1265 PUSHs (sv_2mortal (newSViv (line - 1)));
1266 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE)));
1267}
1268
1269void
1270line_x_to_index (CFPlus::Layout self, int line, int x)
1271 PPCODE:
1272{
1273 PangoLayoutLine *lp;
1274 int index, trailing;
1275
1276 if (line < 0)
1277 XSRETURN_EMPTY;
1278
1279 if (!(lp = pango_layout_get_line (self->pl, line)))
1280 XSRETURN_EMPTY; /* do better */
1281
1282 pango_layout_line_x_to_index (lp, x * PANGO_SCALE, &index, &trailing);
1283
1284 EXTEND (SP, 2);
1285 if (GIMME_V == G_SCALAR)
1286 PUSHs (sv_2mortal (newSViv (index + trailing)));
1287 else
1288 {
417 PUSHs (sv_2mortal (newSViv (h))); 1289 PUSHs (sv_2mortal (newSViv (index)));
418 PUSHs (sv_2mortal (retval)); 1290 PUSHs (sv_2mortal (newSViv (trailing)));
1291 }
419} 1292}
420 1293
1294void
1295render (CFPlus::Layout self, float x, float y, int flags = 0)
1296 PPCODE:
1297 pango_opengl_render_layout_subpixel (
1298 self->pl,
1299 x * PANGO_SCALE, y * PANGO_SCALE,
1300 self->r, self->g, self->b, self->a,
1301 flags
1302 );
1303
421MODULE = CFClient PACKAGE = CFClient::Texture 1304MODULE = CFPlus PACKAGE = CFPlus::Texture
422 1305
1306PROTOTYPES: ENABLE
1307
1308int minpot (int n)
1309
423void 1310void
1311pad (SV *data_, int ow, int oh, int nw, int nh)
1312 CODE:
1313{
1314 if ((nw != ow || nh != oh) && SvOK (data_))
1315 {
1316 STRLEN datalen;
1317 char *data = SvPVbyte (data_, datalen);
1318 int bpp = datalen / (ow * oh);
1319 SV *result_ = sv_2mortal (newSV (nw * nh * bpp));
1320
1321 SvPOK_only (result_);
1322 SvCUR_set (result_, nw * nh * bpp);
1323
1324 memset (SvPVX (result_), 0, nw * nh * bpp);
1325 while (oh--)
1326 memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp);
1327
1328 sv_setsv (data_, result_);
1329 }
1330}
1331
1332void
424draw_quad (SV *self, float x, float y, float w = 0, float h = 0) 1333draw_quad (SV *self, float x, float y, float w = 0., float h = 0.)
425 PROTOTYPE: $$$;$$ 1334 PROTOTYPE: $$$;$$
1335 ALIAS:
1336 draw_quad_alpha = 1
1337 draw_quad_alpha_premultiplied = 2
426 CODE: 1338 CODE:
427{ 1339{
428 HV *hv = (HV *)SvRV (self); 1340 HV *hv = (HV *)SvRV (self);
429 float s = SvNV (*hv_fetch (hv, "s", 1, 1)); 1341 float s = SvNV (*hv_fetch (hv, "s", 1, 1));
430 float t = SvNV (*hv_fetch (hv, "t", 1, 1)); 1342 float t = SvNV (*hv_fetch (hv, "t", 1, 1));
431 int name = SvIV (*hv_fetch (hv, "name", 4, 1)); 1343 int name = SvIV (*hv_fetch (hv, "name", 4, 1));
432 int wrap_mode = SvIV (*hv_fetch (hv, "wrap_mode", 9, 1));
433 1344
434 if (items < 5) 1345 if (items < 5)
435 { 1346 {
436 w = SvNV (*hv_fetch (hv, "w", 1, 1)); 1347 w = SvNV (*hv_fetch (hv, "w", 1, 1));
437 h = SvNV (*hv_fetch (hv, "h", 1, 1)); 1348 h = SvNV (*hv_fetch (hv, "h", 1, 1));
438 } 1349 }
439 1350
1351 if (ix)
1352 {
1353 glEnable (GL_BLEND);
1354
1355 if (ix == 2)
1356 glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1357 else
1358 gl_BlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
1359 GL_ONE , GL_ONE_MINUS_SRC_ALPHA);
1360
1361 glEnable (GL_ALPHA_TEST);
1362 glAlphaFunc (GL_GREATER, 0.01f);
1363 }
1364
440 glBindTexture (GL_TEXTURE_2D, name); 1365 glBindTexture (GL_TEXTURE_2D, name);
441 if (wrap_mode) { 1366
442 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
443 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
444 }
445 glBegin (GL_QUADS); 1367 glBegin (GL_QUADS);
446 glTexCoord2f (0, 0); glVertex2f (x , y ); 1368 glTexCoord2f (0, 0); glVertex2f (x , y );
447 glTexCoord2f (0, t); glVertex2f (x , y + h); 1369 glTexCoord2f (0, t); glVertex2f (x , y + h);
448 glTexCoord2f (s, t); glVertex2f (x + w, y + h); 1370 glTexCoord2f (s, t); glVertex2f (x + w, y + h);
449 glTexCoord2f (s, 0); glVertex2f (x + w, y ); 1371 glTexCoord2f (s, 0); glVertex2f (x + w, y );
450 glEnd (); 1372 glEnd ();
451}
452 1373
1374 if (ix)
1375 {
1376 glDisable (GL_ALPHA_TEST);
1377 glDisable (GL_BLEND);
1378 }
1379}
1380
1381IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1382 CODE:
1383{
1384 GLint width;
1385 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
1386 glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
1387 RETVAL = width > 0;
1388}
1389 OUTPUT:
1390 RETVAL
1391
453MODULE = CFClient PACKAGE = CFClient::Map 1392MODULE = CFPlus PACKAGE = CFPlus::Map
454 1393
455CFClient::Map 1394PROTOTYPES: DISABLE
456new (SV *class, int map_width, int map_height) 1395
1396CFPlus::Map
1397new (SV *class)
457 CODE: 1398 CODE:
458 New (0, RETVAL, 1, struct map); 1399 New (0, RETVAL, 1, struct map);
459 RETVAL->x = 0; 1400 RETVAL->x = 0;
460 RETVAL->y = 0; 1401 RETVAL->y = 0;
461 RETVAL->w = map_width; 1402 RETVAL->w = 0;
462 RETVAL->h = map_height; 1403 RETVAL->h = 0;
463 RETVAL->vx = 0; 1404 RETVAL->ox = 0;
464 RETVAL->vy = 0; 1405 RETVAL->oy = 0;
465 RETVAL->faces = 8192; 1406 RETVAL->faces = 8192; Newz (0, RETVAL->face2tile, RETVAL->faces, tileid);
466 Newz (0, RETVAL->face, RETVAL->faces, mapface); 1407 RETVAL->texs = 8192; Newz (0, RETVAL->tex , RETVAL->texs , maptex);
467 RETVAL->rows = 0; 1408 RETVAL->rows = 0;
468 RETVAL->row = 0; 1409 RETVAL->row = 0;
469 OUTPUT: 1410 OUTPUT:
470 RETVAL 1411 RETVAL
471 1412
472void 1413void
473DESTROY (CFClient::Map self) 1414DESTROY (CFPlus::Map self)
474 CODE: 1415 CODE:
475{ 1416{
476 map_clear (self); 1417 map_clear (self);
477 Safefree (self->face); 1418 Safefree (self->face2tile);
1419 Safefree (self->tex);
478 Safefree (self); 1420 Safefree (self);
479} 1421}
480 1422
481void 1423void
1424resize (CFPlus::Map self, int map_width, int map_height)
1425 CODE:
1426 self->w = map_width;
1427 self->h = map_height;
1428
1429void
482clear (CFClient::Map self) 1430clear (CFPlus::Map self)
483 CODE: 1431 CODE:
484 map_clear (self); 1432 map_clear (self);
485 1433
486void 1434void
1435set_tileid (CFPlus::Map self, int face, int tile)
1436 CODE:
1437{
1438 need_facenum (self, face); self->face2tile [face] = tile;
1439 need_texid (self, tile);
1440}
1441
1442void
1443set_smooth (CFPlus::Map self, int face, int smooth, int level)
1444 CODE:
1445{
1446 tileid texid;
1447 maptex *tex;
1448
1449 if (face < 0 || face >= self->faces)
1450 return;
1451
1452 if (smooth < 0 || smooth >= self->faces)
1453 return;
1454
1455 texid = self->face2tile [face];
1456
1457 if (!texid)
1458 return;
1459
1460 tex = self->tex + texid;
1461 tex->smoothtile = self->face2tile [smooth];
1462 tex->smoothlevel = level;
1463}
1464
1465void
487set_texture (CFClient::Map self, int face, int name, int w, int h, float s, float t, int r, int g, int b, int a) 1466set_texture (CFPlus::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
488 CODE: 1467 CODE:
489{ 1468{
490 while (self->faces < face) 1469 need_texid (self, texid);
1470
1471 {
1472 maptex *tex = self->tex + texid;
1473
1474 tex->name = name;
1475 tex->w = w;
1476 tex->h = h;
1477 tex->s = s;
1478 tex->t = t;
1479 tex->r = r;
1480 tex->g = g;
1481 tex->b = b;
1482 tex->a = a;
1483 }
1484
1485 // somewhat hackish, but for textures that require it, it really
1486 // improves the look, and most others don't suffer.
1487 glBindTexture (GL_TEXTURE_2D, name);
1488 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1489 //glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1490 // use uglier nearest interpolation because linear suffers
1491 // from transparent color bleeding and ugly wrapping effects.
1492 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1493}
1494
1495int
1496ox (CFPlus::Map self)
1497 ALIAS:
1498 oy = 1
1499 x = 2
1500 y = 3
1501 w = 4
1502 h = 5
1503 CODE:
1504 switch (ix)
491 { 1505 {
492 Append (mapface, self->face, self->faces, self->faces); 1506 case 0: RETVAL = self->ox; break;
493 self->faces *= 2; 1507 case 1: RETVAL = self->oy; break;
1508 case 2: RETVAL = self->x; break;
1509 case 3: RETVAL = self->y; break;
1510 case 4: RETVAL = self->w; break;
1511 case 5: RETVAL = self->h; break;
494 } 1512 }
1513 OUTPUT:
1514 RETVAL
495 1515
496 mapface *f = self->face + face;
497
498 f->name = name;
499 f->w = w;
500 f->h = h;
501 f->s = s;
502 f->t = t;
503 f->r = r;
504 f->g = g;
505 f->b = b;
506 f->a = a;
507}
508
509void 1516void
510scroll (CFClient::Map self, int dx, int dy) 1517scroll (CFPlus::Map self, int dx, int dy)
511 CODE: 1518 CODE:
512{ 1519{
513 if (dx > 0) 1520 if (dx > 0)
514 map_blank (self, self->x, self->y, dx - 1, self->h); 1521 map_blank (self, self->x, self->y, dx, self->h);
515 else if (dx < 0) 1522 else if (dx < 0)
516 map_blank (self, self->x + self->w + dx + 1, self->y, 1 - dx, self->h); 1523 map_blank (self, self->x + self->w + dx, self->y, -dx, self->h);
517 1524
518 if (dy > 0) 1525 if (dy > 0)
519 map_blank (self, self->x, self->y, self->w, dy - 1); 1526 map_blank (self, self->x, self->y, self->w, dy);
520 else if (dy < 0) 1527 else if (dy < 0)
521 map_blank (self, self->x, self->y + self->h + dy + 1, self->w, 1 - dy); 1528 map_blank (self, self->x, self->y + self->h + dy, self->w, -dy);
522 1529
523 self->x += dx; 1530 self->ox += dx; self->x += dx;
524 self->y += dy; 1531 self->oy += dy; self->y += dy;
525 1532
526 while (self->y < 0) 1533 while (self->y < 0)
527 { 1534 {
528 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y); 1535 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
529 1536
… …
531 self->y += MAP_EXTEND_Y; 1538 self->y += MAP_EXTEND_Y;
532 } 1539 }
533} 1540}
534 1541
535void 1542void
536map1a_update (CFClient::Map self, SV *data_) 1543map1a_update (CFPlus::Map self, SV *data_, int extmap)
537 CODE: 1544 CODE:
538{ 1545{
539 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 1546 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
540 uint8_t *data_end = (uint8_t *)SvEND (data_); 1547 uint8_t *data_end = (uint8_t *)SvEND (data_);
541 1548 mapcell *cell;
1549 int x, y, flags;
1550
542 while (data < data_end) 1551 while (data < data_end - 1)
543 { 1552 {
544 int flags = (data [0] << 8) + data [1]; data += 2; 1553 flags = (data [0] << 8) + data [1]; data += 2;
545 1554
546 int x = ((flags >> 10) & 63) + self->x; 1555 x = self->x + ((flags >> 10) & 63);
547 int y = ((flags >> 4) & 63) + self->y; 1556 y = self->y + ((flags >> 4) & 63);
548 1557
549 while (y >= self->rows) 1558 cell = map_get_cell (self, x, y);
550 {
551 Prepend (maprow, self->row, self->rows, MAP_EXTEND_Y);
552
553 self->rows += MAP_EXTEND_Y;
554 }
555
556 maprow *row = self->row + y;
557
558 if (!row->col)
559 {
560 Newz (0, row->col, MAP_EXTEND_X, mapcell);
561 row->c0 = self->x - MAP_EXTEND_X / 4;
562 row->c1 = row->c0 + MAP_EXTEND_X;
563 }
564
565 if (row->c0 > x)
566 {
567 int extend = row->c0 - x + MAP_EXTEND_X;
568 Prepend (mapcell, row->col, row->c1 - row->c0, extend);
569 row->c0 -= extend;
570 }
571 else if (x >= row->c1)
572 {
573 int extend = x - row->c1 + MAP_EXTEND_X;
574 Append (mapcell, row->col, row->c1 - row->c0, extend);
575 row->c1 += extend;
576 }
577
578 assert (y >= 0);
579 assert (y < self->rows);
580 assert (x >= row->c0);
581 assert (x < row->c1);
582 mapcell *cell = row->col + (x - row->c0);
583 1559
584 if (flags & 15) 1560 if (flags & 15)
585 { 1561 {
586 if (cell->darkness < 0 && x < self->w && y < self->h) 1562 if (!cell->darkness)
587 { 1563 {
1564 memset (cell, 0, sizeof (*cell));
588 cell->darkness = 0; 1565 cell->darkness = 256;
589 cell->face [0] = 0;
590 cell->face [1] = 0;
591 cell->face [2] = 0;
592 } 1566 }
1567
1568 //TODO: don't trust server data to be in-range(!)
1569
1570 if (flags & 8)
593 1571 {
1572 if (extmap)
1573 {
1574 uint8_t ext, cmd;
1575
1576 do
1577 {
1578 ext = *data++;
1579 cmd = ext & 0x3f;
1580
1581 if (cmd < 4)
1582 cell->darkness = 255 - ext * 64 + 1;
1583 else if (cmd == 5) // health
1584 {
1585 cell->stat_width = 1;
1586 cell->stat_hp = *data++;
1587 }
1588 else if (cmd == 6) // monster width
1589 cell->stat_width = *data++ + 1;
1590 else if (cmd == 0x47)
1591 {
1592 if (*data == 4)
1593 ; // decode player count
1594
1595 data += *data + 1;
1596 }
1597 else if (cmd == 8) // cell flags
1598 cell->flags = *data++;
1599 else if (ext & 0x40) // unknown, multibyte => skip
1600 data += *data + 1;
1601 else
1602 data++;
1603 }
1604 while (ext & 0x80);
1605 }
1606 else
594 cell->darkness = flags & 8 ? *data++ : 255; 1607 cell->darkness = *data++ + 1;
1608 }
595 1609
596 if (flags & 4) 1610 if (flags & 4)
597 { 1611 {
598 cell->face [0] = (data [0] << 8) + data [1]; data += 2; 1612 faceid face = (data [0] << 8) + data [1]; data += 2;
1613 need_facenum (self, face);
1614 cell->tile [0] = self->face2tile [face];
599 } 1615 }
600 1616
601 if (flags & 2) 1617 if (flags & 2)
602 { 1618 {
603 cell->face [1] = (data [0] << 8) + data [1]; data += 2; 1619 faceid face = (data [0] << 8) + data [1]; data += 2;
1620 need_facenum (self, face);
1621 cell->tile [1] = self->face2tile [face];
604 } 1622 }
605 1623
606 if (flags & 1) 1624 if (flags & 1)
607 { 1625 {
608 cell->face [2] = (data [0] << 8) + data [1]; data += 2; 1626 faceid face = (data [0] << 8) + data [1]; data += 2;
1627 need_facenum (self, face);
1628 cell->tile [2] = self->face2tile [face];
609 } 1629 }
610 } 1630 }
611 else 1631 else
612 cell->darkness = -1; 1632 cell->darkness = 0;
613 } 1633 }
614} 1634}
615 1635
616SV * 1636SV *
617mapmap (CFClient::Map self, int w, int h) 1637mapmap (CFPlus::Map self, int x0, int y0, int w, int h)
618 CODE: 1638 CODE:
619{ 1639{
620 int x0, x1, x; 1640 int x1, x;
621 int y0, y1, y; 1641 int y1, y;
622 int z; 1642 int z;
623 SV *map_sv = newSV (w * h * sizeof (uint32_t)); 1643 SV *map_sv = newSV (w * h * sizeof (uint32_t));
624 uint32_t *map = (uint32_t *)SvPVX (map_sv); 1644 uint32_t *map = (uint32_t *)SvPVX (map_sv);
625 1645
626 SvPOK_only (map_sv); 1646 SvPOK_only (map_sv);
627 SvCUR_set (map_sv, w * h * sizeof (uint32_t)); 1647 SvCUR_set (map_sv, w * h * sizeof (uint32_t));
628 1648
629 x0 = self->x - w / 2; x1 = x0 + w; 1649 x0 += self->x; x1 = x0 + w;
630 y0 = self->y - h / 2; y1 = y0 + h; 1650 y0 += self->y; y1 = y0 + h;
631 1651
632 for (y = y0; y < y1; y++) 1652 for (y = y0; y < y1; y++)
633 { 1653 {
634 maprow *row = 0 <= y && y < self->rows 1654 maprow *row = 0 <= y && y < self->rows
635 ? self->row + y 1655 ? self->row + y
… …
643 { 1663 {
644 mapcell *cell = row->col + (x - row->c0); 1664 mapcell *cell = row->col + (x - row->c0);
645 1665
646 for (z = 0; z <= 0; z++) 1666 for (z = 0; z <= 0; z++)
647 { 1667 {
648 uint16_t face = cell->face [z]; 1668 maptex tex = self->tex [cell->tile [z]];
649
650 if (face)
651 {
652 mapface tex = self->face [face];
653 int a0 = 255 - tex.a; 1669 int a0 = 255 - tex.a;
654 int a1 = tex.a; 1670 int a1 = tex.a;
655 1671
656 r = (r * a0 + tex.r * a1) / 255; 1672 r = (r * a0 + tex.r * a1) / 255;
657 g = (g * a0 + tex.g * a1) / 255; 1673 g = (g * a0 + tex.g * a1) / 255;
658 b = (b * a0 + tex.b * a1) / 255; 1674 b = (b * a0 + tex.b * a1) / 255;
659 a = (a * a0 + tex.a * a1) / 255; 1675 a = (a * a0 + tex.a * a1) / 255;
660 }
661 } 1676 }
662 } 1677 }
663 1678
664 *map++ = (r ) 1679 *map++ = (r )
665 | (g << 8) 1680 | (g << 8)
… …
672} 1687}
673 OUTPUT: 1688 OUTPUT:
674 RETVAL 1689 RETVAL
675 1690
676void 1691void
677draw (CFClient::Map self, int shift_x, int shift_y, int x0, int y0, int sw, int sh) 1692draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T)
678 PPCODE: 1693 CODE:
679{ 1694{
680 int sw4 = (sw + 3) & ~3; 1695 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
681 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh)); 1696 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
682 uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv); 1697 static uint8_t smooth_max[256][256]; // egad, fats and wasteful on memory (64k)
1698 smooth_key skey;
1699 int x, y, z;
1700 int last_name;
683 1701
684 SvPOK_only (darkness_sv); 1702 // thats current max. sorry.
685 SvCUR_set (darkness_sv, sw4 * sh); 1703 if (sw > 255) sw = 255;
1704 if (sh > 255) sh = 255;
686 1705
687 int vx = self->x + (self->w - sw) / 2 - shift_x; 1706 // clear key, in case of extra padding
688 int vy = self->y + (self->h - sh) / 2 - shift_y; 1707 memset (&skey, 0, sizeof (skey));
689
690 if (0)
691 {
692 int vx = self->vx = self->w >= sw
693 ? self->x + (self->w - sw) / 2
694 : MIN (self->x, MAX (self->x + self->w - sw + 1, self->vx));
695
696 int vy = self->vy = self->h >= sh
697 ? self->y + (self->h - sh) / 2
698 : MIN (self->y, MAX (self->y + self->h - sh + 1, self->vy));
699 }
700 1708
701 glColor4ub (255, 255, 255, 255); 1709 glColor4ub (255, 255, 255, 255);
702 1710
1711 glEnable (GL_BLEND);
703 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 1712 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
704 glEnable (GL_BLEND);
705 glEnable (GL_TEXTURE_2D); 1713 glEnable (GL_TEXTURE_2D);
706 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 1714 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
707 1715
708 int x, y, z;
709
710 int last_name = 0;
711
712 glBegin (GL_QUADS); 1716 glBegin (GL_QUADS);
713 1717
1718 last_name = 0;
1719
1720 mx += self->x;
1721 my += self->y;
1722
1723 // first pass: determine smooth_max
1724 // rather ugly, if you ask me
1725 // could also be stored inside mapcell and updated on change
1726 memset (smooth_max, 0, sizeof (smooth_max));
1727
1728 for (y = 0; y < sh; y++)
1729 if (0 <= y + my && y + my < self->rows)
1730 {
1731 maprow *row = self->row + (y + my);
1732
1733 for (x = 0; x < sw; x++)
1734 if (row->c0 <= x + mx && x + mx < row->c1)
1735 {
1736 mapcell *cell = row->col + (x + mx - row->c0);
1737
1738 smooth_max[x + 1][y + 1] =
1739 MAX (self->tex [cell->tile [0]].smoothlevel,
1740 MAX (self->tex [cell->tile [1]].smoothlevel,
1741 self->tex [cell->tile [2]].smoothlevel));
1742 }
1743 }
1744
714 for (z = 0; z < 3; z++) 1745 for (z = 0; z <= 2; z++)
1746 {
1747 memset (smooth_level, 0, sizeof (smooth_level));
1748
715 for (y = 0; y < sh; y++) 1749 for (y = 0; y < sh; y++)
716 if (0 <= y + vy && y + vy < self->rows) 1750 if (0 <= y + my && y + my < self->rows)
717 { 1751 {
718 maprow *row = self->row + (y + vy); 1752 maprow *row = self->row + (y + my);
719 1753
720 for (x = 0; x < sw; x++) 1754 for (x = 0; x < sw; x++)
721 if (row->c0 <= x + vx && x + vx < row->c1) 1755 if (row->c0 <= x + mx && x + mx < row->c1)
722 { 1756 {
723 mapcell *cell = row->col + (x + vx - row->c0); 1757 mapcell *cell = row->col + (x + mx - row->c0);
724
725 darkness[y * sw4 + x] = cell->darkness < 0
726 ? 255 - FOW_DARKNESS
727 : 255 - cell->darkness;
728
729 uint16_t face = cell->face [z]; 1758 tileid tile = cell->tile [z];
730 1759
731 if (face) 1760 if (tile)
1761 {
1762 maptex tex = self->tex [tile];
1763 int px = (x + 1) * T - tex.w;
1764 int py = (y + 1) * T - tex.h;
1765
1766 // suppressing texture state switches here
1767 // is only moderately effective, but worth the extra effort
1768 if (last_name != tex.name)
1769 {
1770 if (!tex.name)
1771 tex = self->tex [2]; /* missing, replace by noface */
1772
1773 glEnd ();
1774 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1775 glBegin (GL_QUADS);
1776 }
1777
1778 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1779 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
1780 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1781 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1782
1783 if (cell->flags && z == 2)
1784 {
1785 if (cell->flags & 1)
1786 {
1787 maptex tex = self->tex [1];
1788 int px = x * T + T * 2 / 32;
1789 int py = y * T - T * 6 / 32;
1790
1791 glEnd ();
1792 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1793 glBegin (GL_QUADS);
1794
1795 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1796 glTexCoord2f (0 , tex.t); glVertex2f (px , py + T);
1797 glTexCoord2f (tex.s, tex.t); glVertex2f (px + T, py + T);
1798 glTexCoord2f (tex.s, 0 ); glVertex2f (px + T, py );
1799 }
1800 }
1801
1802 // update smooth hash
1803 if (tex.smoothtile)
1804 {
1805 skey.tile = tex.smoothtile;
1806 skey.level = tex.smoothlevel;
1807
1808 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31);
1809
1810 // add bits to current tile and all neighbours. skey.x|y is
1811 // shifted +1|+1 so we always stay positive.
1812
1813 // bits is ___n cccc CCCC bbbb
1814 // n do not draw borders&corners
1815 // c draw these corners, but...
1816 // C ... not these
1817 // b draw these borders
1818
1819 // borders: 1 ┃· 2 ━━ 4 ·┃ 8 ··
1820 // ┃· ·· ·┃ ━━
1821
1822 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
1823 // ·· ·· ·┏ ┓·
1824
1825 // full tile
1826 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000);
1827
1828 // borders
1829 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091);
1830 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032);
1831 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064);
1832 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8);
1833
1834 // corners
1835 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);
1836 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);
1837 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);
1838 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);
1839 }
1840 }
1841 }
1842 }
1843
1844 // go through all smoothlevels, lowest to highest, then draw.
1845 // this is basically counting sort
1846 {
1847 int w, b;
1848
1849 for (w = 0; w < 256 / 32; ++w)
1850 {
1851 uint32_t smask = smooth_level [w];
1852 if (smask)
1853 for (b = 0; b < 32; ++b)
1854 if (smask & (((uint32_t)1) << b))
732 { 1855 {
733 mapface tex = self->face [face]; 1856 int level = (w << 5) | b;
1857 HE *he;
734 1858
735 int px = (x + 1) * 32 - tex.w; 1859 hv_iterinit (smooth);
736 int py = (y + 1) * 32 - tex.h; 1860 while ((he = hv_iternext (smooth)))
737
738 if (last_name != tex.name)
739 { 1861 {
1862 smooth_key *skey = (smooth_key *)HeKEY (he);
1863 IV bits = SvIVX (HeVAL (he));
1864
1865 if (!(bits & 0x1000)
1866 && skey->level == level
1867 && level > smooth_max [skey->x][skey->y])
1868 {
1869 maptex tex = self->tex [skey->tile];
1870 int px = (((int)skey->x) - 1) * T;
1871 int py = (((int)skey->y) - 1) * T;
1872 int border = bits & 15;
1873 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1874 float dx = tex.s * .0625f; // 16 images/row
1875 float dy = tex.t * .5f ; // 2 images/column
1876
1877 // this time naively avoiding texture state changes
1878 // save gobs of state changes.
1879 if (last_name != tex.name)
1880 {
1881 if (!tex.name)
1882 continue; // smoothing not yet available
1883
740 glEnd (); 1884 glEnd ();
741 last_name = tex.name;
742 glBindTexture (GL_TEXTURE_2D, last_name); 1885 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
743 glBegin (GL_QUADS); 1886 glBegin (GL_QUADS);
1887 }
1888
1889 if (border)
1890 {
1891 float ox = border * dx;
1892
1893 glTexCoord2f (ox , 0.f ); glVertex2f (px , py );
1894 glTexCoord2f (ox , dy ); glVertex2f (px , py + T);
1895 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py + T);
1896 glTexCoord2f (ox + dx, 0.f ); glVertex2f (px + T, py );
1897 }
1898
1899 if (corner)
1900 {
1901 float ox = corner * dx;
1902
1903 glTexCoord2f (ox , dy ); glVertex2f (px , py );
1904 glTexCoord2f (ox , dy * 2.f); glVertex2f (px , py + T);
1905 glTexCoord2f (ox + dx, dy * 2.f); glVertex2f (px + T, py + T);
1906 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py );
1907 }
1908 }
744 } 1909 }
745
746 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
747 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
748 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
749 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
750 } 1910 }
751 }
752 } 1911 }
1912 }
1913
1914 hv_clear (smooth);
1915 }
753 1916
754 glEnd (); 1917 glEnd ();
755 1918
756 glDisable (GL_TEXTURE_2D); 1919 glDisable (GL_TEXTURE_2D);
757 glDisable (GL_BLEND); 1920 glDisable (GL_BLEND);
758 1921
1922 // top layer: overlays such as the health bar
1923 for (y = 0; y < sh; y++)
1924 if (0 <= y + my && y + my < self->rows)
1925 {
1926 maprow *row = self->row + (y + my);
1927
1928 for (x = 0; x < sw; x++)
1929 if (row->c0 <= x + mx && x + mx < row->c1)
1930 {
1931 mapcell *cell = row->col + (x + mx - row->c0);
1932
1933 int px = x * T;
1934 int py = y * T;
1935
1936 if (cell->stat_hp)
1937 {
1938 int width = cell->stat_width * T;
1939 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
1940
1941 glColor3ub (0, 0, 0);
1942 glRectf (px + 1, py - thick - 2,
1943 px + width - 1, py);
1944
1945 glColor3ub (cell->stat_hp, 255 - cell->stat_hp, 0);
1946 glRectf (px + 2,
1947 py - thick - 1,
1948 px + width - 2 - cell->stat_hp * (width - 4) / 255, py - 1);
1949 }
1950 }
1951 }
1952}
1953
1954void
1955draw_magicmap (CFPlus::Map self, int dx, int dy, int w, int h, unsigned char *data)
1956 CODE:
1957{
1958 static float color[16][3] = {
1959 { 0.00F, 0.00F, 0.00F },
1960 { 1.00F, 1.00F, 1.00F },
1961 { 0.00F, 0.00F, 0.55F },
1962 { 1.00F, 0.00F, 0.00F },
1963
1964 { 1.00F, 0.54F, 0.00F },
1965 { 0.11F, 0.56F, 1.00F },
1966 { 0.93F, 0.46F, 0.00F },
1967 { 0.18F, 0.54F, 0.34F },
1968
1969 { 0.56F, 0.73F, 0.56F },
1970 { 0.80F, 0.80F, 0.80F },
1971 { 0.55F, 0.41F, 0.13F },
1972 { 0.99F, 0.77F, 0.26F },
1973
1974 { 0.74F, 0.65F, 0.41F },
1975
1976 { 0.00F, 1.00F, 1.00F },
1977 { 1.00F, 0.00F, 1.00F },
1978 { 1.00F, 1.00F, 0.00F },
1979 };
1980
1981 int x, y;
1982
1983 glEnable (GL_TEXTURE_2D);
1984 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1985 glEnable (GL_BLEND);
1986 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1987 glBegin (GL_QUADS);
1988
1989 for (y = 0; y < h; y++)
1990 for (x = 0; x < w; x++)
1991 {
1992 unsigned char m = data [x + y * w];
1993
1994 if (m)
1995 {
1996 float *c = color [m & 15];
1997
1998 float tx1 = m & 0x40 ? 0.5 : 0.;
1999 float tx2 = tx1 + 0.5;
2000
2001 glColor4f (c[0], c[1], c[2], 0.75);
2002 glTexCoord2f (tx1, 0.); glVertex2i (x , y );
2003 glTexCoord2f (tx1, 1.); glVertex2i (x , y + 1);
2004 glTexCoord2f (tx2, 1.); glVertex2i (x + 1, y + 1);
2005 glTexCoord2f (tx2, 0.); glVertex2i (x + 1, y );
2006 }
2007 }
2008
2009 glEnd ();
2010 glDisable (GL_BLEND);
2011 glDisable (GL_TEXTURE_2D);
2012}
2013
2014void
2015fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh)
2016 PPCODE:
2017{
2018 int x, y;
2019 int sw1 = sw + 2;
2020 int sh1 = sh + 2;
2021 int sh3 = sh * 3;
2022 int sw34 = (sw * 3 + 3) & ~3;
2023 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2024 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3));
2025 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2026
2027 SvPOK_only (darkness3_sv);
2028 SvCUR_set (darkness3_sv, sw34 * sh3);
2029
2030 mx += self->x - 1;
2031 my += self->y - 1;
2032
2033 memset (darkness1, 255, sw1 * sh1);
2034
2035 for (y = 0; y < sh1; y++)
2036 if (0 <= y + my && y + my < self->rows)
2037 {
2038 maprow *row = self->row + (y + my);
2039
2040 for (x = 0; x < sw1; x++)
2041 if (row->c0 <= x + mx && x + mx < row->c1)
2042 {
2043 mapcell *cell = row->col + (x + mx - row->c0);
2044
2045 darkness1 [y * sw1 + x] = cell->darkness
2046 ? 255 - (cell->darkness - 1)
2047 : 255 - FOW_DARKNESS;
2048 }
2049 }
2050
2051 for (y = 0; y < sh; ++y)
2052 for (x = 0; x < sw; ++x)
2053 {
2054 uint8_t d11 = darkness1 [(y ) * sw1 + x ];
2055 uint8_t d21 = darkness1 [(y ) * sw1 + x + 1];
2056 uint8_t d31 = darkness1 [(y ) * sw1 + x + 2];
2057 uint8_t d12 = darkness1 [(y + 1) * sw1 + x ];
2058 uint8_t d22 = darkness1 [(y + 1) * sw1 + x + 1];
2059 uint8_t d32 = darkness1 [(y + 1) * sw1 + x + 2];
2060 uint8_t d13 = darkness1 [(y + 2) * sw1 + x ];
2061 uint8_t d23 = darkness1 [(y + 2) * sw1 + x + 1];
2062 uint8_t d33 = darkness1 [(y + 2) * sw1 + x + 2];
2063
2064 uint8_t r11 = (d11 + d21 + d12) / 3;
2065 uint8_t r21 = d21;
2066 uint8_t r31 = (d21 + d31 + d32) / 3;
2067
2068 uint8_t r12 = d12;
2069 uint8_t r22 = d22;
2070 uint8_t r32 = d32;
2071
2072 uint8_t r13 = (d13 + d23 + d12) / 3;
2073 uint8_t r23 = d23;
2074 uint8_t r33 = (d23 + d33 + d32) / 3;
2075
2076 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11);
2077 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21);
2078 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31);
2079 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12);
2080 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22);
2081 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32);
2082 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13);
2083 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23);
2084 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33);
2085 }
2086
2087 free (darkness1);
2088
759 EXTEND (SP, 3); 2089 EXTEND (SP, 3);
760 PUSHs (sv_2mortal (newSViv (sw4))); 2090 PUSHs (sv_2mortal (newSViv (sw34)));
761 PUSHs (sv_2mortal (newSViv (sh))); 2091 PUSHs (sv_2mortal (newSViv (sh3)));
762 PUSHs (darkness_sv); 2092 PUSHs (darkness3_sv);
763} 2093}
764 2094
2095SV *
2096get_rect (CFPlus::Map self, int x0, int y0, int w, int h)
2097 CODE:
2098{
2099 int x, y, x1, y1;
2100 SV *data_sv = newSV (w * h * 7 + 5);
2101 uint8_t *data = (uint8_t *)SvPVX (data_sv);
2102
2103 *data++ = 0; /* version 0 format */
2104 *data++ = w >> 8; *data++ = w;
2105 *data++ = h >> 8; *data++ = h;
2106
2107 // we need to do this 'cause we don't keep an absolute coord system for rows
2108 // TODO: treat rows as we treat columns
2109 map_get_row (self, y0 + self->y - self->oy);//D
2110 map_get_row (self, y0 + self->y - self->oy + h - 1);//D
2111
2112 x0 += self->x - self->ox;
2113 y0 += self->y - self->oy;
2114
2115 x1 = x0 + w;
2116 y1 = y0 + h;
2117
2118 for (y = y0; y < y1; y++)
2119 {
2120 maprow *row = 0 <= y && y < self->rows
2121 ? self->row + y
2122 : 0;
2123
2124 for (x = x0; x < x1; x++)
2125 {
2126 if (row && row->c0 <= x && x < row->c1)
2127 {
2128 mapcell *cell = row->col + (x - row->c0);
2129 uint8_t flags = 0;
2130
2131 if (cell->tile [0]) flags |= 1;
2132 if (cell->tile [1]) flags |= 2;
2133 if (cell->tile [2]) flags |= 4;
2134
2135 *data++ = flags;
2136
2137 if (flags & 1)
2138 {
2139 tileid tile = cell->tile [0];
2140 *data++ = tile >> 8;
2141 *data++ = tile;
2142 }
2143
2144 if (flags & 2)
2145 {
2146 tileid tile = cell->tile [1];
2147 *data++ = tile >> 8;
2148 *data++ = tile;
2149 }
2150
2151 if (flags & 4)
2152 {
2153 tileid tile = cell->tile [2];
2154 *data++ = tile >> 8;
2155 *data++ = tile;
2156 }
2157 }
2158 else
2159 *data++ = 0;
2160 }
2161 }
2162
2163 SvPOK_only (data_sv);
2164 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2165 RETVAL = data_sv;
2166}
2167 OUTPUT:
2168 RETVAL
2169
2170void
2171set_rect (CFPlus::Map self, int x0, int y0, uint8_t *data)
2172 PPCODE:
2173{
2174 int x, y, z;
2175 int w, h;
2176 int x1, y1;
2177
2178 if (*data++ != 0)
2179 return; /* version mismatch */
2180
2181 w = *data++ << 8; w |= *data++;
2182 h = *data++ << 8; h |= *data++;
2183
2184 // we need to do this 'cause we don't keep an absolute coord system for rows
2185 // TODO: treat rows as we treat columns
2186 map_get_row (self, y0 + self->y - self->oy);//D
2187 map_get_row (self, y0 + self->y - self->oy + h - 1);//D
2188
2189 x0 += self->x - self->ox;
2190 y0 += self->y - self->oy;
2191
2192 x1 = x0 + w;
2193 y1 = y0 + h;
2194
2195 for (y = y0; y < y1; y++)
2196 {
2197 maprow *row = map_get_row (self, y);
2198
2199 for (x = x0; x < x1; x++)
2200 {
2201 uint8_t flags = *data++;
2202
2203 if (flags)
2204 {
2205 mapcell *cell = row_get_cell (row, x);
2206 tileid tile[3] = { 0, 0, 0 };
2207
2208 if (flags & 1) { tile[0] = *data++ << 8; tile[0] |= *data++; }
2209 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
2210 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
2211
2212 if (cell->darkness == 0)
2213 {
2214 cell->darkness = 0;
2215
2216 for (z = 0; z <= 2; z++)
2217 {
2218 tileid t = tile [z];
2219
2220 if (t >= self->texs || (t && !self->tex [t].name))
2221 {
2222 XPUSHs (sv_2mortal (newSViv (t)));
2223 need_texid (self, t);
2224 }
2225
2226 cell->tile [z] = t;
2227 }
2228 }
2229 }
2230 }
2231 }
2232}
2233
2234MODULE = CFPlus PACKAGE = CFPlus::MixChunk
2235
2236PROTOTYPES: DISABLE
2237
2238CFPlus::MixChunk
2239new_from_file (SV *class, char *path)
2240 CODE:
2241 RETVAL = Mix_LoadWAV (path);
2242 OUTPUT:
2243 RETVAL
2244
2245void
2246DESTROY (CFPlus::MixChunk self)
2247 CODE:
2248 Mix_FreeChunk (self);
2249
2250int
2251volume (CFPlus::MixChunk self, int volume = -1)
2252 CODE:
2253 RETVAL = Mix_VolumeChunk (self, volume);
2254 OUTPUT:
2255 RETVAL
2256
2257int
2258play (CFPlus::MixChunk self, int channel = -1, int loops = 0, int ticks = -1)
2259 CODE:
2260 RETVAL = Mix_PlayChannelTimed (channel, self, loops, ticks);
2261 OUTPUT:
2262 RETVAL
2263
2264MODULE = CFPlus PACKAGE = CFPlus::MixMusic
2265
2266int
2267volume (int volume = -1)
2268 PROTOTYPE: ;$
2269 CODE:
2270 RETVAL = Mix_VolumeMusic (volume);
2271 OUTPUT:
2272 RETVAL
2273
2274int
2275fade_out (int ms)
2276 CODE:
2277 RETVAL = Mix_FadeOutMusic (ms);
2278 OUTPUT:
2279 RETVAL
2280
2281CFPlus::MixMusic
2282new_from_file (SV *class, char *path)
2283 CODE:
2284 RETVAL = Mix_LoadMUS (path);
2285 OUTPUT:
2286 RETVAL
2287
2288void
2289DESTROY (CFPlus::MixMusic self)
2290 CODE:
2291 Mix_FreeMusic (self);
2292
2293int
2294play (CFPlus::MixMusic self, int loops = -1)
2295 CODE:
2296 RETVAL = Mix_PlayMusic (self, loops);
2297 OUTPUT:
2298 RETVAL
2299
2300int
2301fade_in_pos (CFPlus::MixMusic self, int loops, int ms, double position)
2302 CODE:
2303 RETVAL = Mix_FadeInMusicPos (self, loops, ms, position);
2304 OUTPUT:
2305 RETVAL
2306
2307MODULE = CFPlus PACKAGE = CFPlus::OpenGL
2308
2309PROTOTYPES: ENABLE
2310
2311BOOT:
2312{
2313 HV *stash = gv_stashpv ("CFPlus::OpenGL", 1);
2314 static const struct {
2315 const char *name;
2316 IV iv;
2317 } *civ, const_iv[] = {
2318# define const_iv(name) { # name, (IV)name }
2319 const_iv (GL_VENDOR),
2320 const_iv (GL_VERSION),
2321 const_iv (GL_EXTENSIONS),
2322 const_iv (GL_COLOR_MATERIAL),
2323 const_iv (GL_SMOOTH),
2324 const_iv (GL_FLAT),
2325 const_iv (GL_DITHER),
2326 const_iv (GL_BLEND),
2327 const_iv (GL_CULL_FACE),
2328 const_iv (GL_SCISSOR_TEST),
2329 const_iv (GL_DEPTH_TEST),
2330 const_iv (GL_ALPHA_TEST),
2331 const_iv (GL_NORMALIZE),
2332 const_iv (GL_RESCALE_NORMAL),
2333 const_iv (GL_FRONT),
2334 const_iv (GL_BACK),
2335 const_iv (GL_AUX0),
2336 const_iv (GL_AND),
2337 const_iv (GL_ONE),
2338 const_iv (GL_ZERO),
2339 const_iv (GL_SRC_ALPHA),
2340 const_iv (GL_DST_ALPHA),
2341 const_iv (GL_ONE_MINUS_SRC_ALPHA),
2342 const_iv (GL_ONE_MINUS_DST_ALPHA),
2343 const_iv (GL_SRC_ALPHA_SATURATE),
2344 const_iv (GL_RGB),
2345 const_iv (GL_RGBA),
2346 const_iv (GL_RGBA4),
2347 const_iv (GL_RGBA8),
2348 const_iv (GL_RGB5_A1),
2349 const_iv (GL_UNSIGNED_BYTE),
2350 const_iv (GL_UNSIGNED_SHORT),
2351 const_iv (GL_UNSIGNED_INT),
2352 const_iv (GL_ALPHA),
2353 const_iv (GL_INTENSITY),
2354 const_iv (GL_LUMINANCE),
2355 const_iv (GL_LUMINANCE_ALPHA),
2356 const_iv (GL_FLOAT),
2357 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV),
2358 const_iv (GL_COMPILE),
2359 const_iv (GL_PROXY_TEXTURE_1D),
2360 const_iv (GL_PROXY_TEXTURE_2D),
2361 const_iv (GL_TEXTURE_1D),
2362 const_iv (GL_TEXTURE_2D),
2363 const_iv (GL_TEXTURE_ENV),
2364 const_iv (GL_TEXTURE_MAG_FILTER),
2365 const_iv (GL_TEXTURE_MIN_FILTER),
2366 const_iv (GL_TEXTURE_ENV_MODE),
2367 const_iv (GL_TEXTURE_WRAP_S),
2368 const_iv (GL_TEXTURE_WRAP_T),
2369 const_iv (GL_REPEAT),
2370 const_iv (GL_CLAMP),
2371 const_iv (GL_CLAMP_TO_EDGE),
2372 const_iv (GL_NEAREST),
2373 const_iv (GL_LINEAR),
2374 const_iv (GL_NEAREST_MIPMAP_NEAREST),
2375 const_iv (GL_LINEAR_MIPMAP_NEAREST),
2376 const_iv (GL_NEAREST_MIPMAP_LINEAR),
2377 const_iv (GL_LINEAR_MIPMAP_LINEAR),
2378 const_iv (GL_GENERATE_MIPMAP),
2379 const_iv (GL_MODULATE),
2380 const_iv (GL_DECAL),
2381 const_iv (GL_REPLACE),
2382 const_iv (GL_DEPTH_BUFFER_BIT),
2383 const_iv (GL_COLOR_BUFFER_BIT),
2384 const_iv (GL_PROJECTION),
2385 const_iv (GL_MODELVIEW),
2386 const_iv (GL_COLOR_LOGIC_OP),
2387 const_iv (GL_SEPARABLE_2D),
2388 const_iv (GL_CONVOLUTION_2D),
2389 const_iv (GL_CONVOLUTION_BORDER_MODE),
2390 const_iv (GL_CONSTANT_BORDER),
2391 const_iv (GL_LINES),
2392 const_iv (GL_LINE_STRIP),
2393 const_iv (GL_LINE_LOOP),
2394 const_iv (GL_QUADS),
2395 const_iv (GL_QUAD_STRIP),
2396 const_iv (GL_TRIANGLES),
2397 const_iv (GL_TRIANGLE_STRIP),
2398 const_iv (GL_TRIANGLE_FAN),
2399 const_iv (GL_PERSPECTIVE_CORRECTION_HINT),
2400 const_iv (GL_POINT_SMOOTH_HINT),
2401 const_iv (GL_LINE_SMOOTH_HINT),
2402 const_iv (GL_POLYGON_SMOOTH_HINT),
2403 const_iv (GL_GENERATE_MIPMAP_HINT),
2404 const_iv (GL_FASTEST),
2405 const_iv (GL_DONT_CARE),
2406 const_iv (GL_NICEST),
2407 const_iv (GL_V2F),
2408 const_iv (GL_V3F),
2409 const_iv (GL_T2F_V3F),
2410 const_iv (GL_T2F_N3F_V3F),
2411# undef const_iv
2412 };
2413
2414 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
2415 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
2416
2417 texture_av = newAV ();
2418 AvREAL_off (texture_av);
2419}
2420
2421char *
2422gl_vendor ()
2423 CODE:
2424 RETVAL = (char *)glGetString (GL_VENDOR);
2425 OUTPUT:
2426 RETVAL
2427
2428char *
2429gl_version ()
2430 CODE:
2431 RETVAL = (char *)glGetString (GL_VERSION);
2432 OUTPUT:
2433 RETVAL
2434
2435char *
2436gl_extensions ()
2437 CODE:
2438 RETVAL = (char *)glGetString (GL_EXTENSIONS);
2439 OUTPUT:
2440 RETVAL
2441
2442const char *glGetString (GLenum pname)
2443
2444GLint glGetInteger (GLenum pname)
2445 CODE:
2446 glGetIntegerv (pname, &RETVAL);
2447 OUTPUT:
2448 RETVAL
2449
2450GLdouble glGetDouble (GLenum pname)
2451 CODE:
2452 glGetDoublev (pname, &RETVAL);
2453 OUTPUT:
2454 RETVAL
2455
2456int glGetError ()
2457
2458void glFinish ()
2459
2460void glClear (int mask)
2461
2462void glClearColor (float r, float g, float b, float a = 1.0)
2463 PROTOTYPE: @
2464
2465void glEnable (int cap)
2466
2467void glDisable (int cap)
2468
2469void glShadeModel (int mode)
2470
2471void glHint (int target, int mode)
2472
2473void glBlendFunc (int sfactor, int dfactor)
2474
2475void glBlendFuncSeparate (int sa, int da, int saa, int daa)
2476 CODE:
2477 gl_BlendFuncSeparate (sa, da, saa, daa);
2478
2479void glDepthMask (int flag)
2480
2481void glLogicOp (int opcode)
2482
2483void glColorMask (int red, int green, int blue, int alpha)
2484
2485void glMatrixMode (int mode)
2486
2487void glPushMatrix ()
2488
2489void glPopMatrix ()
2490
2491void glLoadIdentity ()
2492
2493void glDrawBuffer (int buffer)
2494
2495void glReadBuffer (int buffer)
2496
2497# near_ and far_ are due to microsofts buggy "c" compiler
2498void glFrustum (double left, double right, double bottom, double top, double near_, double far_)
2499
2500# near_ and far_ are due to microsofts buggy "c" compiler
2501void glOrtho (double left, double right, double bottom, double top, double near_, double far_)
2502
2503void glViewport (int x, int y, int width, int height)
2504
2505void glScissor (int x, int y, int width, int height)
2506
2507void glTranslate (float x, float y, float z = 0.)
2508 CODE:
2509 glTranslatef (x, y, z);
2510
2511void glScale (float x, float y, float z = 1.)
2512 CODE:
2513 glScalef (x, y, z);
2514
2515void glRotate (float angle, float x, float y, float z)
2516 CODE:
2517 glRotatef (angle, x, y, z);
2518
2519void glBegin (int mode)
2520
2521void glEnd ()
2522
2523void glColor (float r, float g, float b, float a = 1.0)
2524 PROTOTYPE: @
2525 ALIAS:
2526 glColor_premultiply = 1
2527 CODE:
2528 if (ix)
2529 {
2530 r *= a;
2531 g *= a;
2532 b *= a;
2533 }
2534 // microsoft visual "c" rounds instead of truncating...
2535 glColor4f (r, g, b, a);
2536
2537void glInterleavedArrays (int format, int stride, char *data)
2538
2539void glDrawElements (int mode, int count, int type, char *indices)
2540
2541# 1.2 void glDrawRangeElements (int mode, int start, int end
2542
2543void glRasterPos (float x, float y, float z = 0.)
2544 CODE:
2545 glRasterPos3f (0, 0, z);
2546 glBitmap (0, 0, 0, 0, x, y, 0);
2547
2548void glVertex (float x, float y, float z = 0.)
2549 CODE:
2550 glVertex3f (x, y, z);
2551
2552void glTexCoord (float s, float t)
2553 CODE:
2554 glTexCoord2f (s, t);
2555
2556void glTexEnv (int target, int pname, float param)
2557 CODE:
2558 glTexEnvf (target, pname, param);
2559
2560void glTexParameter (int target, int pname, float param)
2561 CODE:
2562 glTexParameterf (target, pname, param);
2563
2564void glBindTexture (int target, int name)
2565
2566void glConvolutionParameter (int target, int pname, float params)
2567 CODE:
2568 if (gl.ConvolutionParameterf)
2569 gl.ConvolutionParameterf (target, pname, params);
2570
2571void glConvolutionFilter2D (int target, int internalformat, int width, int height, int format, int type, char *data)
2572 CODE:
2573 if (gl.ConvolutionFilter2D)
2574 gl.ConvolutionFilter2D (target, internalformat, width, height, format, type, data);
2575
2576void glSeparableFilter2D (int target, int internalformat, int width, int height, int format, int type, char *row, char *column)
2577 CODE:
2578 if (gl.SeparableFilter2D)
2579 gl.SeparableFilter2D (target, internalformat, width, height, format, type, row, column);
2580
2581void glTexImage2D (int target, int level, int internalformat, int width, int height, int border, int format, int type, char *data)
2582
2583void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
2584
2585void glDrawPixels (int width, int height, int format, int type, char *pixels)
2586
2587void glPixelZoom (float x, float y)
2588
2589void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR)
2590
2591int glGenTexture ()
2592 CODE:
2593 RETVAL = gen_texture ();
2594 OUTPUT:
2595 RETVAL
2596
2597void glDeleteTexture (int name)
2598 CODE:
2599 del_texture (name);
2600
2601int glGenList ()
2602 CODE:
2603 RETVAL = glGenLists (1);
2604 OUTPUT:
2605 RETVAL
2606
2607void glDeleteList (int list)
2608 CODE:
2609 glDeleteLists (list, 1);
2610
2611void glNewList (int list, int mode = GL_COMPILE)
2612
2613void glEndList ()
2614
2615void glCallList (int list)
2616
2617MODULE = CFPlus PACKAGE = CFPlus::UI::Base
2618
2619PROTOTYPES: DISABLE
2620
2621void
2622find_widget (SV *widget, NV x, NV y)
2623 PPCODE:
2624{
2625 if (within_widget (widget, x, y))
2626 XPUSHs (widget);
2627}
2628

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines