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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines