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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines