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.141 by root, Fri Aug 18 01:01:00 2006 UTC vs.
Revision 1.208 by root, Sat Jul 21 16:07:53 2007 UTC

1#ifdef _WIN32 1#ifdef _WIN32
2# define WIN32_LEAN_AND_MEAN 2# define WIN32_LEAN_AND_MEAN
3# define _WIN32_WINNT 0x0500 // needed to get win2000 api calls 3# define NTDDI_VERSION NTDDI_WIN2K // needed to get win2000 api calls
4# include <malloc.h> 4# include <malloc.h>
5# include <windows.h> 5# include <windows.h>
6# include <wininet.h>
6# pragma warning(disable:4244) 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>
7#endif 14#endif
8 15
9#include "EXTERN.h" 16#include "EXTERN.h"
10#include "perl.h" 17#include "perl.h"
11#include "XSUB.h" 18#include "XSUB.h"
12 19
13#ifdef _WIN32 20#ifdef _WIN32
14# undef pipe 21# undef pipe
15#endif 22#endif
16 23
24#include <assert.h>
17#include <math.h> 25#include <math.h>
18#include <string.h> 26#include <string.h>
19#include <stdio.h> 27#include <stdio.h>
20#include <stdlib.h> 28#include <stdlib.h>
21 29
22#include <SDL.h> 30#include <SDL.h>
31#include <SDL_thread.h>
23#include <SDL_endian.h> 32#include <SDL_endian.h>
24#include <SDL_image.h> 33#include <SDL_image.h>
25#include <SDL_mixer.h> 34#include <SDL_mixer.h>
26#include <SDL_opengl.h> 35#include <SDL_opengl.h>
27 36
36# include <sys/types.h> 45# include <sys/types.h>
37# include <sys/socket.h> 46# include <sys/socket.h>
38# include <netinet/in.h> 47# include <netinet/in.h>
39# include <netinet/tcp.h> 48# include <netinet/tcp.h>
40# include <inttypes.h> 49# include <inttypes.h>
41#else
42 typedef unsigned char uint8_t;
43 typedef unsigned short uint16_t;
44 typedef unsigned int uint32_t;
45 typedef signed char int8_t;
46 typedef signed short int16_t;
47 typedef signed int int32_t;
48#endif 50#endif
49 51
50#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, objetc replacement character */ 52#define OBJ_STR "\xef\xbf\xbc" /* U+FFFC, object replacement character */
51 53
52#define FOW_DARKNESS 32 54#define FOW_DARKNESS 32
53 55
54#define MAP_EXTEND_X 32 56#define MAP_EXTEND_X 32
55#define MAP_EXTEND_Y 512 57#define MAP_EXTEND_Y 512
60# define PARACHUTE SDL_INIT_NOPARACHUTE 62# define PARACHUTE SDL_INIT_NOPARACHUTE
61#else 63#else
62# define PARACHUTE 0 64# define PARACHUTE 0
63#endif 65#endif
64 66
67static AV *texture_av;
68
65static struct 69static struct
66{ 70{
67#define GL_FUNC(ptr,name) ptr name; 71#define GL_FUNC(ptr,name) ptr name;
68#include "glfunc.h" 72#include "glfunc.h"
69#undef GL_FUNC 73#undef GL_FUNC
70} gl; 74} gl;
71 75
76static void
72static void gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa) 77gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa)
73{ 78{
74 if (gl.BlendFuncSeparate) 79 if (gl.BlendFuncSeparate)
75 gl.BlendFuncSeparate (sa, da, saa, daa); 80 gl.BlendFuncSeparate (sa, da, saa, daa);
76 else if (gl.BlendFuncSeparateEXT) 81 else if (gl.BlendFuncSeparateEXT)
77 gl.BlendFuncSeparateEXT (sa, da, saa, daa); 82 gl.BlendFuncSeparateEXT (sa, da, saa, daa);
78 else 83 else
79 glBlendFunc (sa, da); 84 glBlendFunc (sa, da);
80} 85}
81 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
82#include "texcache.c" 111#include "texcache.c"
83 112
84#include "pango-font.c" 113#include "pango-font.c"
85#include "pango-fontmap.c" 114#include "pango-fontmap.c"
86#include "pango-render.c" 115#include "pango-render.c"
159 188
160 *w = rect.width; 189 *w = rect.width;
161 *h = rect.height; 190 *h = rect.height;
162} 191}
163 192
193typedef uint16_t tileid;
164typedef uint16_t mapface; 194typedef uint16_t faceid;
165 195
166typedef struct { 196typedef struct {
167 GLint name; 197 int name;
168 int w, h; 198 int w, h;
169 float s, t; 199 float s, t;
170 uint8_t r, g, b, a; 200 uint8_t r, g, b, a;
201 tileid smoothtile;
202 uint8_t smoothlevel;
171} maptex; 203} maptex;
172 204
173typedef struct { 205typedef struct {
206 uint32_t player;
207 tileid tile[3];
174 int16_t darkness; 208 uint16_t darkness;
175 mapface face[3]; 209 uint8_t stat_width, stat_hp, flags, smoothmax;
176} mapcell; 210} mapcell;
177 211
178typedef struct { 212typedef struct {
179 int32_t c0, c1; 213 int32_t c0, c1;
180 mapcell *col; 214 mapcell *col;
181} maprow; 215} maprow;
182 216
183typedef struct map { 217typedef struct map {
184 int x, y, w, h; 218 int x, y, w, h;
185 int ox, oy; /* offset to virtual global coordinate system */ 219 int ox, oy; /* offset to virtual global coordinate system */
186 int faces; 220 int faces; tileid *face2tile; // [faceid]
187 mapface *face; 221 int texs; maptex *tex; // [tileid]
188
189 int texs;
190 maptex *tex;
191 222
192 int32_t rows; 223 int32_t rows;
193 maprow *row; 224 maprow *row;
194} *CFPlus__Map; 225} *CFPlus__Map;
195 226
215 return ptr; 246 return ptr;
216} 247}
217 248
218#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))
219#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))
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}
220 271
221static maprow * 272static maprow *
222map_get_row (CFPlus__Map self, int y) 273map_get_row (CFPlus__Map self, int y)
223{ 274{
224 if (0 > y) 275 if (0 > y)
293static void 344static void
294map_blank (CFPlus__Map self, int x0, int y0, int w, int h) 345map_blank (CFPlus__Map self, int x0, int y0, int w, int h)
295{ 346{
296 int x, y; 347 int x, y;
297 maprow *row; 348 maprow *row;
349 mapcell *cell;
298 350
299 for (y = y0; y < y0 + h; y++) 351 for (y = y0; y < y0 + h; y++)
300 if (y >= 0) 352 if (y >= 0)
301 { 353 {
302 if (y >= self->rows) 354 if (y >= self->rows)
308 if (x >= row->c0) 360 if (x >= row->c0)
309 { 361 {
310 if (x >= row->c1) 362 if (x >= row->c1)
311 break; 363 break;
312 364
313 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;
314 } 371 }
315 } 372 }
373}
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);
316} 389}
317 390
318static void 391static void
319music_finished (void) 392music_finished (void)
320{ 393{
354 n |= n >> 4; 427 n |= n >> 4;
355 n |= n >> 8; 428 n |= n >> 8;
356 n |= n >> 16; 429 n |= n >> 16;
357 430
358 return n + 1; 431 return n + 1;
432}
433
434/* SDL should provide this, really. */
435#define SDLK_MODIFIER_MIN 300
436#define SDLK_MODIFIER_MAX 314
437
438/******************************************************************************/
439
440static int
441within_widget (SV *widget, NV x, NV y)
442{
443 HV *self;
444 SV **svp;
445 NV wx, ww, wy, wh;
446
447 if (!SvROK (widget))
448 return 0;
449
450 self = (HV *)SvRV (widget);
451
452 if (SvTYPE (self) != SVt_PVHV)
453 return 0;
454
455 svp = hv_fetch (self, "y", 1, 0); wy = svp ? SvNV (*svp) : 0.;
456 if (y < wy)
457 return 0;
458
459 svp = hv_fetch (self, "h", 1, 0); wh = svp ? SvNV (*svp) : 0.;
460 if (y >= wy + wh)
461 return 0;
462
463 svp = hv_fetch (self, "x", 1, 0); wx = svp ? SvNV (*svp) : 0.;
464 if (x < wx)
465 return 0;
466
467 svp = hv_fetch (self, "w", 1, 0); ww = svp ? SvNV (*svp) : 0.;
468 if (x >= wx + ww)
469 return 0;
470
471 svp = hv_fetch (self, "can_events", sizeof ("can_events") - 1, 0);
472 if (!svp || !SvTRUE (*svp))
473 return 0;
474
475 return 1;
359} 476}
360 477
361MODULE = CFPlus PACKAGE = CFPlus 478MODULE = CFPlus PACKAGE = CFPlus
362 479
363PROTOTYPES: ENABLE 480PROTOTYPES: ENABLE
368 static const struct { 485 static const struct {
369 const char *name; 486 const char *name;
370 IV iv; 487 IV iv;
371 } *civ, const_iv[] = { 488 } *civ, const_iv[] = {
372# define const_iv(name) { # name, (IV)name } 489# define const_iv(name) { # name, (IV)name }
490 const_iv (SDLK_MODIFIER_MIN),
491 const_iv (SDLK_MODIFIER_MAX),
492
373 const_iv (SDL_ACTIVEEVENT), 493 const_iv (SDL_ACTIVEEVENT),
374 const_iv (SDL_KEYDOWN), 494 const_iv (SDL_KEYDOWN),
375 const_iv (SDL_KEYUP), 495 const_iv (SDL_KEYUP),
376 const_iv (SDL_MOUSEMOTION), 496 const_iv (SDL_MOUSEMOTION),
377 const_iv (SDL_MOUSEBUTTONDOWN), 497 const_iv (SDL_MOUSEBUTTONDOWN),
386 const_iv (SDL_EVENT_RESERVEDA), 506 const_iv (SDL_EVENT_RESERVEDA),
387 const_iv (SDL_EVENT_RESERVEDB), 507 const_iv (SDL_EVENT_RESERVEDB),
388 const_iv (SDL_VIDEORESIZE), 508 const_iv (SDL_VIDEORESIZE),
389 const_iv (SDL_VIDEOEXPOSE), 509 const_iv (SDL_VIDEOEXPOSE),
390 const_iv (SDL_USEREVENT), 510 const_iv (SDL_USEREVENT),
511
512 const_iv (SDL_APPINPUTFOCUS),
513 const_iv (SDL_APPMOUSEFOCUS),
514 const_iv (SDL_APPACTIVE),
515
391 const_iv (SDLK_KP0), 516 const_iv (SDLK_KP0),
392 const_iv (SDLK_KP1), 517 const_iv (SDLK_KP1),
393 const_iv (SDLK_KP2), 518 const_iv (SDLK_KP2),
394 const_iv (SDLK_KP3), 519 const_iv (SDLK_KP3),
395 const_iv (SDLK_KP4), 520 const_iv (SDLK_KP4),
450 const_iv (SDLK_BREAK), 575 const_iv (SDLK_BREAK),
451 const_iv (SDLK_MENU), 576 const_iv (SDLK_MENU),
452 const_iv (SDLK_POWER), 577 const_iv (SDLK_POWER),
453 const_iv (SDLK_EURO), 578 const_iv (SDLK_EURO),
454 const_iv (SDLK_UNDO), 579 const_iv (SDLK_UNDO),
580
455 const_iv (KMOD_NONE), 581 const_iv (KMOD_NONE),
582 const_iv (KMOD_SHIFT),
456 const_iv (KMOD_LSHIFT), 583 const_iv (KMOD_LSHIFT),
457 const_iv (KMOD_RSHIFT), 584 const_iv (KMOD_RSHIFT),
585 const_iv (KMOD_CTRL),
458 const_iv (KMOD_LCTRL), 586 const_iv (KMOD_LCTRL),
459 const_iv (KMOD_RCTRL), 587 const_iv (KMOD_RCTRL),
588 const_iv (KMOD_ALT),
460 const_iv (KMOD_LALT), 589 const_iv (KMOD_LALT),
461 const_iv (KMOD_RALT), 590 const_iv (KMOD_RALT),
591 const_iv (KMOD_META),
462 const_iv (KMOD_LMETA), 592 const_iv (KMOD_LMETA),
463 const_iv (KMOD_RMETA), 593 const_iv (KMOD_RMETA),
464 const_iv (KMOD_NUM), 594 const_iv (KMOD_NUM),
465 const_iv (KMOD_CAPS), 595 const_iv (KMOD_CAPS),
466 const_iv (KMOD_MODE), 596 const_iv (KMOD_MODE),
467 const_iv (KMOD_CTRL),
468 const_iv (KMOD_SHIFT),
469 const_iv (KMOD_ALT),
470 const_iv (KMOD_META)
471# undef const_iv 597# undef const_iv
472 }; 598 };
473 599
474 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 600 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
475 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 601 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
602
603 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
604 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
476} 605}
606
607void
608weaken (SV *rv)
609 PROTOTYPE: $
610 CODE:
611 sv_rvweaken (rv);
477 612
478int 613int
479in_destruct () 614in_destruct ()
480 CODE: 615 CODE:
481 RETVAL = PL_main_cv == Nullcv; 616 RETVAL = PL_main_cv == Nullcv;
493 opengl_fontmap = pango_opengl_font_map_new (); 628 opengl_fontmap = pango_opengl_font_map_new ();
494 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0); 629 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
495 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap); 630 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
496} 631}
497 632
633char *
634SDL_GetError ()
635
498int 636int
499SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE) 637SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE)
500 638
501void 639void
502SDL_Quit () 640SDL_Quit ()
503 641
504void 642void
505SDL_ListModes () 643SDL_ListModes (int rgb, int alpha)
506 PPCODE: 644 PPCODE:
507{ 645{
508 SDL_Rect **m; 646 SDL_Rect **m;
509 647
510 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5); 648 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
511 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5); 649 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
512 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5); 650 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
513 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 1); 651 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
514 652
515 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15); 653 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15);
516 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 0); 654 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE , 0);
517 655
518 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE, 0); 656 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE , 0);
519 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0); 657 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
520 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE, 0); 658 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
521 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0); 659 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
522 660
523 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); 661 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
524#if SDL_VERSION_ATLEAST(1,2,10) 662#if SDL_VERSION_ATLEAST(1,2,10)
525 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1); 663 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
526 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1); 664 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
527#endif 665#endif
528 666
529 SDL_EnableUNICODE (1);
530 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
531
532 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL); 667 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
533 668
534 if (m && m != (SDL_Rect **)-1) 669 if (m && m != (SDL_Rect **)-1)
535 while (*m) 670 while (*m)
536 { 671 {
672 if ((*m)->w >= 640 && (*m)->h >= 480)
673 {
537 AV *av = newAV (); 674 AV *av = newAV ();
538 av_push (av, newSViv ((*m)->w)); 675 av_push (av, newSViv ((*m)->w));
539 av_push (av, newSViv ((*m)->h)); 676 av_push (av, newSViv ((*m)->h));
677 av_push (av, newSViv (rgb));
678 av_push (av, newSViv (alpha));
540 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av))); 679 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
680 }
541 681
542 ++m; 682 ++m;
543 } 683 }
544} 684}
545 685
546char *
547SDL_GetError ()
548
549int 686int
550SDL_SetVideoMode (int w, int h, int fullscreen) 687SDL_SetVideoMode (int w, int h, int rgb, int alpha, int fullscreen)
551 CODE: 688 CODE:
689{
690 SDL_EnableUNICODE (1);
691 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
692
693 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
694 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
695 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
696 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
697
552 RETVAL = !!SDL_SetVideoMode ( 698 RETVAL = !!SDL_SetVideoMode (
553 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0) 699 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0)
554 ); 700 );
701
555 if (RETVAL) 702 if (RETVAL)
556 { 703 {
704 av_clear (texture_av);
705
557 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+"); 706 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+");
558# define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name); 707#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
559# include "glfunc.h" 708#include "glfunc.h"
560# undef GL_FUNC 709#undef GL_FUNC
561 } 710 }
711}
562 OUTPUT: 712 OUTPUT:
563 RETVAL 713 RETVAL
564 714
565void 715void
566SDL_GL_SwapBuffers () 716SDL_GL_SwapBuffers ()
567 717
568char * 718char *
569SDL_GetKeyName (int sym) 719SDL_GetKeyName (int sym)
570 720
721int
722SDL_GetAppState ()
723
571void 724void
572SDL_PollEvent () 725poll_events ()
573 PPCODE: 726 PPCODE:
574{ 727{
575 SDL_Event ev; 728 SDL_Event ev;
576 729
577 while (SDL_PollEvent (&ev)) 730 SDL_PumpEvents ();
731 while (SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_ALLEVENTS) > 0)
578 { 732 {
579 HV *hv = newHV (); 733 HV *hv = newHV ();
580 hv_store (hv, "type", 4, newSViv (ev.type), 0); 734 hv_store (hv, "type", 4, newSViv (ev.type), 0);
581 735
582 switch (ev.type) 736 switch (ev.type)
584 case SDL_KEYDOWN: 738 case SDL_KEYDOWN:
585 case SDL_KEYUP: 739 case SDL_KEYUP:
586 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 740 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
587 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 741 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
588 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0); 742 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0);
743 hv_store (hv, "cmod", 4, newSViv (SDL_GetModState ()), 0); /* current mode */
589 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 744 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
590 break; 745 break;
591 746
592 case SDL_ACTIVEEVENT: 747 case SDL_ACTIVEEVENT:
593 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 748 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
594 hv_store (hv, "state", 5, newSViv (ev.active.state), 0); 749 hv_store (hv, "state", 5, newSViv (ev.active.state), 0);
595 break; 750 break;
596 751
597 case SDL_MOUSEMOTION: 752 case SDL_MOUSEMOTION:
753 {
754 int state = ev.motion.state;
755 int x = ev.motion.x;
756 int y = ev.motion.y;
757 int xrel = ev.motion.xrel;
758 int yrel = ev.motion.yrel;
759
760 /* do simplistic event compression */
761 while (SDL_PeepEvents (&ev, 1, SDL_PEEKEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)) > 0
762 && state == ev.motion.state)
763 {
764 xrel += ev.motion.xrel;
765 yrel += ev.motion.yrel;
766 x = ev.motion.x;
767 y = ev.motion.y;
768 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
769 }
770
598 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 771 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);
599
600 hv_store (hv, "state", 5, newSViv (ev.motion.state), 0); 772 hv_store (hv, "state", 5, newSViv (state), 0);
601 hv_store (hv, "x", 1, newSViv (ev.motion.x), 0); 773 hv_store (hv, "x", 1, newSViv (x), 0);
602 hv_store (hv, "y", 1, newSViv (ev.motion.y), 0); 774 hv_store (hv, "y", 1, newSViv (y), 0);
603 hv_store (hv, "xrel", 4, newSViv (ev.motion.xrel), 0); 775 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
604 hv_store (hv, "yrel", 4, newSViv (ev.motion.yrel), 0); 776 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
777 }
605 break; 778 break;
606 779
607 case SDL_MOUSEBUTTONDOWN: 780 case SDL_MOUSEBUTTONDOWN:
608 case SDL_MOUSEBUTTONUP: 781 case SDL_MOUSEBUTTONUP:
609 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 782 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);
638Mix_AllocateChannels (int numchans = -1) 811Mix_AllocateChannels (int numchans = -1)
639 812
640void 813void
641lowdelay (int fd, int val = 1) 814lowdelay (int fd, int val = 1)
642 CODE: 815 CODE:
816 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val));
817
818void
819win32_proxy_info ()
820 PPCODE:
821{
643#ifndef _WIN32 822#ifdef _WIN32
644 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val)); 823 char buffer[2048];
824 DWORD buflen;
825
826 EXTEND (SP, 3);
827
828 buflen = sizeof (buffer);
829 if (InternetQueryOption (0, INTERNET_OPTION_PROXY, (void *)buffer, &buflen))
830 if (((INTERNET_PROXY_INFO *)buffer)->dwAccessType == INTERNET_OPEN_TYPE_PROXY)
831 {
832 PUSHs (newSVpv (((INTERNET_PROXY_INFO *)buffer)->lpszProxy, 0));
833
834 buflen = sizeof (buffer);
835 if (InternetQueryOption (0, INTERNET_OPTION_PROXY_USERNAME, (void *)buffer, &buflen))
836 {
837 PUSHs (newSVpv (buffer, 0));
838
839 buflen = sizeof (buffer);
840 if (InternetQueryOption (0, INTERNET_OPTION_PROXY_PASSWORD, (void *)buffer, &buflen))
841 PUSHs (newSVpv (buffer, 0));
842 }
843 }
645#endif 844#endif
845}
646 846
647void 847void
648add_font (char *file) 848add_font (char *file)
649 CODE: 849 CODE:
650 FcConfigAppFontAddFile (0, (const FcChar8 *)file); 850 FcConfigAppFontAddFile (0, (const FcChar8 *)file);
754 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR); 954 MessageBox (0, message, "Crossfire+ Fatal Error", MB_OK | MB_ICONERROR);
755#endif 955#endif
756 _exit (1); 956 _exit (1);
757 957
758void 958void
759_exit (int retval) 959_exit (int retval = 0)
760 CODE: 960 CODE:
961#ifdef WIN32
962 ExitThread (retval); // unclean, please beam me up
963#else
761 _exit (retval); 964 _exit (retval);
965#endif
966
967void
968debug ()
969 CODE:
970{
971#if DEBUG
972 VALGRIND_DO_LEAK_CHECK;
973#endif
974}
762 975
763MODULE = CFPlus PACKAGE = CFPlus::Font 976MODULE = CFPlus PACKAGE = CFPlus::Font
977
978PROTOTYPES: DISABLE
764 979
765CFPlus::Font 980CFPlus::Font
766new_from_file (SV *class, char *path, int id = 0) 981new_from_file (SV *class, char *path, int id = 0)
767 CODE: 982 CODE:
768{ 983{
779 CODE: 994 CODE:
780 pango_font_description_free (self); 995 pango_font_description_free (self);
781 996
782void 997void
783make_default (CFPlus::Font self) 998make_default (CFPlus::Font self)
999 PROTOTYPE: $
784 CODE: 1000 CODE:
785 default_font = self; 1001 default_font = self;
786 1002
787MODULE = CFPlus PACKAGE = CFPlus::Layout 1003MODULE = CFPlus PACKAGE = CFPlus::Layout
788 1004
1005PROTOTYPES: DISABLE
1006
789void 1007void
790reset_glyph_cache () 1008reset_glyph_cache ()
1009 PROTOTYPE:
791 CODE: 1010 CODE:
792 tc_clear (); 1011 tc_clear ();
793 1012
794CFPlus::Layout 1013CFPlus::Layout
795new (SV *class) 1014new (SV *class)
1013xy_to_index (CFPlus::Layout self, int x, int y) 1232xy_to_index (CFPlus::Layout self, int x, int y)
1014 CODE: 1233 CODE:
1015{ 1234{
1016 int index, trailing; 1235 int index, trailing;
1017 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing); 1236 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing);
1018 RETVAL = index; 1237 RETVAL = index + trailing;
1019} 1238}
1020 OUTPUT: 1239 OUTPUT:
1021 RETVAL 1240 RETVAL
1022 1241
1023void 1242void
1029 1248
1030 EXTEND (SP, 3); 1249 EXTEND (SP, 3);
1031 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1250 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));
1032 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1251 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
1033 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1252 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE)));
1253}
1254
1255void
1256index_to_line_x (CFPlus::Layout self, int index, int trailing = 0)
1257 PPCODE:
1258{
1259 int line, x;
1260
1261 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
1262 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
1263
1264 EXTEND (SP, 2);
1265 PUSHs (sv_2mortal (newSViv (line - 1)));
1266 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE)));
1267}
1268
1269void
1270line_x_to_index (CFPlus::Layout self, int line, int x)
1271 PPCODE:
1272{
1273 PangoLayoutLine *lp;
1274 int index, trailing;
1275
1276 if (line < 0)
1277 XSRETURN_EMPTY;
1278
1279 if (!(lp = pango_layout_get_line (self->pl, line)))
1280 XSRETURN_EMPTY; /* do better */
1281
1282 pango_layout_line_x_to_index (lp, x * PANGO_SCALE, &index, &trailing);
1283
1284 EXTEND (SP, 2);
1285 if (GIMME_V == G_SCALAR)
1286 PUSHs (sv_2mortal (newSViv (index + trailing)));
1287 else
1288 {
1289 PUSHs (sv_2mortal (newSViv (index)));
1290 PUSHs (sv_2mortal (newSViv (trailing)));
1291 }
1034} 1292}
1035 1293
1036void 1294void
1037render (CFPlus::Layout self, float x, float y, int flags = 0) 1295render (CFPlus::Layout self, float x, float y, int flags = 0)
1038 PPCODE: 1296 PPCODE:
1043 flags 1301 flags
1044 ); 1302 );
1045 1303
1046MODULE = CFPlus PACKAGE = CFPlus::Texture 1304MODULE = CFPlus PACKAGE = CFPlus::Texture
1047 1305
1048void 1306PROTOTYPES: ENABLE
1049pad2pot (SV *data_, SV *w_, SV *h_)
1050 CODE:
1051{
1052 int ow = SvIV (w_);
1053 int oh = SvIV (h_);
1054 1307
1055 if (ow && oh) 1308int minpot (int n)
1309
1310void
1311pad (SV *data_, int ow, int oh, int nw, int nh)
1312 CODE:
1313{
1314 if ((nw != ow || nh != oh) && SvOK (data_))
1056 { 1315 {
1057 int nw = minpot (ow);
1058 int nh = minpot (oh);
1059
1060 if (nw != ow || nh != oh)
1061 {
1062 if (SvOK (data_))
1063 {
1064 STRLEN datalen; 1316 STRLEN datalen;
1065 char *data = SvPVbyte (data_, datalen); 1317 char *data = SvPVbyte (data_, datalen);
1066 int bpp = datalen / (ow * oh); 1318 int bpp = datalen / (ow * oh);
1067 SV *result_ = sv_2mortal (newSV (nw * nh * bpp)); 1319 SV *result_ = sv_2mortal (newSV (nw * nh * bpp));
1068 1320
1069 SvPOK_only (result_); 1321 SvPOK_only (result_);
1070 SvCUR_set (result_, nw * nh * bpp); 1322 SvCUR_set (result_, nw * nh * bpp);
1071 1323
1072 memset (SvPVX (result_), 0, nw * nh * bpp); 1324 memset (SvPVX (result_), 0, nw * nh * bpp);
1073 while (oh--) 1325 while (oh--)
1074 memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp); 1326 memcpy (SvPVX (result_) + oh * nw * bpp, data + oh * ow * bpp, ow * bpp);
1075 1327
1076 sv_setsv (data_, result_); 1328 sv_setsv (data_, result_);
1077 }
1078
1079 sv_setiv (w_, nw);
1080 sv_setiv (h_, nh);
1081 }
1082 } 1329 }
1083} 1330}
1084 1331
1085void 1332void
1086draw_quad (SV *self, float x, float y, float w = 0., float h = 0.) 1333draw_quad (SV *self, float x, float y, float w = 0., float h = 0.)
1129 glDisable (GL_ALPHA_TEST); 1376 glDisable (GL_ALPHA_TEST);
1130 glDisable (GL_BLEND); 1377 glDisable (GL_BLEND);
1131 } 1378 }
1132} 1379}
1133 1380
1381IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1382 CODE:
1383{
1384 GLint width;
1385 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
1386 glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
1387 RETVAL = width > 0;
1388}
1389 OUTPUT:
1390 RETVAL
1391
1134MODULE = CFPlus PACKAGE = CFPlus::Map 1392MODULE = CFPlus PACKAGE = CFPlus::Map
1135 1393
1394PROTOTYPES: DISABLE
1395
1136CFPlus::Map 1396CFPlus::Map
1137new (SV *class, int map_width, int map_height) 1397new (SV *class)
1138 CODE: 1398 CODE:
1139 New (0, RETVAL, 1, struct map); 1399 New (0, RETVAL, 1, struct map);
1140 RETVAL->x = 0; 1400 RETVAL->x = 0;
1141 RETVAL->y = 0; 1401 RETVAL->y = 0;
1142 RETVAL->w = map_width; 1402 RETVAL->w = 0;
1143 RETVAL->h = map_height; 1403 RETVAL->h = 0;
1144 RETVAL->ox = 0; 1404 RETVAL->ox = 0;
1145 RETVAL->oy = 0; 1405 RETVAL->oy = 0;
1146 RETVAL->faces = 8192; 1406 RETVAL->faces = 8192; Newz (0, RETVAL->face2tile, RETVAL->faces, tileid);
1147 Newz (0, RETVAL->face, RETVAL->faces, mapface); 1407 RETVAL->texs = 8192; Newz (0, RETVAL->tex , RETVAL->texs , maptex);
1148 RETVAL->texs = 8192;
1149 Newz (0, RETVAL->tex, RETVAL->texs, maptex);
1150 RETVAL->rows = 0; 1408 RETVAL->rows = 0;
1151 RETVAL->row = 0; 1409 RETVAL->row = 0;
1152 OUTPUT: 1410 OUTPUT:
1153 RETVAL 1411 RETVAL
1154 1412
1155void 1413void
1156DESTROY (CFPlus::Map self) 1414DESTROY (CFPlus::Map self)
1157 CODE: 1415 CODE:
1158{ 1416{
1159 map_clear (self); 1417 map_clear (self);
1160 Safefree (self->face); 1418 Safefree (self->face2tile);
1161 Safefree (self->tex); 1419 Safefree (self->tex);
1162 Safefree (self); 1420 Safefree (self);
1163} 1421}
1164 1422
1165void 1423void
1424resize (CFPlus::Map self, int map_width, int map_height)
1425 CODE:
1426 self->w = map_width;
1427 self->h = map_height;
1428
1429void
1166clear (CFPlus::Map self) 1430clear (CFPlus::Map self)
1167 CODE: 1431 CODE:
1168 map_clear (self); 1432 map_clear (self);
1169 1433
1170void 1434void
1171set_face (CFPlus::Map self, int face, int texid) 1435set_tileid (CFPlus::Map self, int face, int tile)
1172 CODE: 1436 CODE:
1173{ 1437{
1174 while (self->faces <= face) 1438 need_facenum (self, face); self->face2tile [face] = tile;
1175 { 1439 need_texid (self, tile);
1176 Append (mapface, self->face, self->faces, self->faces); 1440}
1177 self->faces *= 2;
1178 }
1179 1441
1180 self->face [face] = texid; 1442void
1443set_smooth (CFPlus::Map self, int face, int smooth, int level)
1444 CODE:
1445{
1446 tileid texid;
1447 maptex *tex;
1448
1449 if (face < 0 || face >= self->faces)
1450 return;
1451
1452 if (smooth < 0 || smooth >= self->faces)
1453 return;
1454
1455 texid = self->face2tile [face];
1456
1457 if (!texid)
1458 return;
1459
1460 tex = self->tex + texid;
1461 tex->smoothtile = self->face2tile [smooth];
1462 tex->smoothlevel = level;
1181} 1463}
1182 1464
1183void 1465void
1184set_texture (CFPlus::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a) 1466set_texture (CFPlus::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
1185 CODE: 1467 CODE:
1186{ 1468{
1187 while (self->texs <= texid) 1469 need_texid (self, texid);
1188 {
1189 Append (maptex, self->tex, self->texs, self->texs);
1190 self->texs *= 2;
1191 }
1192 1470
1193 { 1471 {
1194 maptex *tex = self->tex + texid; 1472 maptex *tex = self->tex + texid;
1195 1473
1196 tex->name = name; 1474 tex->name = name;
1238void 1516void
1239scroll (CFPlus::Map self, int dx, int dy) 1517scroll (CFPlus::Map self, int dx, int dy)
1240 CODE: 1518 CODE:
1241{ 1519{
1242 if (dx > 0) 1520 if (dx > 0)
1243 map_blank (self, self->x, self->y, dx - 1, self->h); 1521 map_blank (self, self->x, self->y, dx, self->h);
1244 else if (dx < 0) 1522 else if (dx < 0)
1245 map_blank (self, self->x + self->w + dx + 1, self->y, 1 - dx, self->h); 1523 map_blank (self, self->x + self->w + dx, self->y, -dx, self->h);
1246 1524
1247 if (dy > 0) 1525 if (dy > 0)
1248 map_blank (self, self->x, self->y, self->w, dy - 1); 1526 map_blank (self, self->x, self->y, self->w, dy);
1249 else if (dy < 0) 1527 else if (dy < 0)
1250 map_blank (self, self->x, self->y + self->h + dy + 1, self->w, 1 - dy); 1528 map_blank (self, self->x, self->y + self->h + dy, self->w, -dy);
1251 1529
1252 self->ox += dx; self->x += dx; 1530 self->ox += dx; self->x += dx;
1253 self->oy += dy; self->y += dy; 1531 self->oy += dy; self->y += dy;
1254 1532
1255 while (self->y < 0) 1533 while (self->y < 0)
1268 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 1546 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1269 uint8_t *data_end = (uint8_t *)SvEND (data_); 1547 uint8_t *data_end = (uint8_t *)SvEND (data_);
1270 mapcell *cell; 1548 mapcell *cell;
1271 int x, y, flags; 1549 int x, y, flags;
1272 1550
1273 while (data < data_end) 1551 while (data < data_end - 1)
1274 { 1552 {
1275 flags = (data [0] << 8) + data [1]; data += 2; 1553 flags = (data [0] << 8) + data [1]; data += 2;
1276 1554
1277 x = self->x + ((flags >> 10) & 63); 1555 x = self->x + ((flags >> 10) & 63);
1278 y = self->y + ((flags >> 4) & 63); 1556 y = self->y + ((flags >> 4) & 63);
1279 1557
1280 cell = map_get_cell (self, x, y); 1558 cell = map_get_cell (self, x, y);
1281 1559
1282 if (flags & 15) 1560 if (flags & 15)
1283 { 1561 {
1284 if (cell->darkness < 0) 1562 if (!cell->darkness)
1285 { 1563 {
1564 memset (cell, 0, sizeof (*cell));
1286 cell->darkness = 0; 1565 cell->darkness = 256;
1287 cell->face [0] = 0;
1288 cell->face [1] = 0;
1289 cell->face [2] = 0;
1290 } 1566 }
1567
1568 //TODO: don't trust server data to be in-range(!)
1291 1569
1292 if (flags & 8) 1570 if (flags & 8)
1293 { 1571 {
1294 fprintf (stderr, "oi\n");//D
1295 if (extmap) 1572 if (extmap)
1296 { 1573 {
1297 uint8_t ext, cmd; 1574 uint8_t ext, cmd;
1298 1575
1299 do 1576 do
1300 { 1577 {
1301
1302 ext = *data++; 1578 ext = *data++;
1303 cmd = ext & 0x7f; 1579 cmd = ext & 0x3f;
1304 1580
1305 fprintf (stderr, "extcmd = %x\n", ext);//D
1306
1307 if (ext < 4) 1581 if (cmd < 4)
1308 cell->darkness = 255 - ext * 64; 1582 cell->darkness = 255 - ext * 64 + 1;
1583 else if (cmd == 5) // health
1584 {
1585 cell->stat_width = 1;
1586 cell->stat_hp = *data++;
1587 }
1588 else if (cmd == 6) // monster width
1589 cell->stat_width = *data++ + 1;
1590 else if (cmd == 0x47)
1591 {
1592 if (*data == 4)
1593 ; // decode player count
1594
1595 data += *data + 1;
1596 }
1597 else if (cmd == 8) // cell flags
1598 cell->flags = *data++;
1599 else if (ext & 0x40) // unknown, multibyte => skip
1600 data += *data + 1;
1601 else
1602 data++;
1309 } 1603 }
1310 while (cmd & 0x80); 1604 while (ext & 0x80);
1311 } 1605 }
1312 else 1606 else
1313 cell->darkness = flags & 8 ? *data++ : 255; 1607 cell->darkness = *data++ + 1;
1314 } 1608 }
1315
1316 //TODO: don't trust server data to be in-range(!)
1317 1609
1318 if (flags & 4) 1610 if (flags & 4)
1319 { 1611 {
1320 cell->face [0] = self->face [(data [0] << 8) + data [1]]; data += 2; 1612 faceid face = (data [0] << 8) + data [1]; data += 2;
1613 need_facenum (self, face);
1614 cell->tile [0] = self->face2tile [face];
1321 } 1615 }
1322 1616
1323 if (flags & 2) 1617 if (flags & 2)
1324 { 1618 {
1325 cell->face [1] = self->face [(data [0] << 8) + data [1]]; data += 2; 1619 faceid face = (data [0] << 8) + data [1]; data += 2;
1620 need_facenum (self, face);
1621 cell->tile [1] = self->face2tile [face];
1326 } 1622 }
1327 1623
1328 if (flags & 1) 1624 if (flags & 1)
1329 { 1625 {
1330 cell->face [2] = self->face [(data [0] << 8) + data [1]]; data += 2; 1626 faceid face = (data [0] << 8) + data [1]; data += 2;
1627 need_facenum (self, face);
1628 cell->tile [2] = self->face2tile [face];
1331 } 1629 }
1332 } 1630 }
1333 else 1631 else
1334 cell->darkness = -1; 1632 cell->darkness = 0;
1335 } 1633 }
1336} 1634}
1337 1635
1338SV * 1636SV *
1339mapmap (CFPlus::Map self, int x0, int y0, int w, int h) 1637mapmap (CFPlus::Map self, int x0, int y0, int w, int h)
1365 { 1663 {
1366 mapcell *cell = row->col + (x - row->c0); 1664 mapcell *cell = row->col + (x - row->c0);
1367 1665
1368 for (z = 0; z <= 0; z++) 1666 for (z = 0; z <= 0; z++)
1369 { 1667 {
1370 mapface face = cell->face [z];
1371
1372 if (face)
1373 {
1374 maptex tex = self->tex [face]; 1668 maptex tex = self->tex [cell->tile [z]];
1375 int a0 = 255 - tex.a; 1669 int a0 = 255 - tex.a;
1376 int a1 = tex.a; 1670 int a1 = tex.a;
1377 1671
1378 r = (r * a0 + tex.r * a1) / 255; 1672 r = (r * a0 + tex.r * a1) / 255;
1379 g = (g * a0 + tex.g * a1) / 255; 1673 g = (g * a0 + tex.g * a1) / 255;
1380 b = (b * a0 + tex.b * a1) / 255; 1674 b = (b * a0 + tex.b * a1) / 255;
1381 a = (a * a0 + tex.a * a1) / 255; 1675 a = (a * a0 + tex.a * a1) / 255;
1382 }
1383 } 1676 }
1384 } 1677 }
1385 1678
1386 *map++ = (r ) 1679 *map++ = (r )
1387 | (g << 8) 1680 | (g << 8)
1394} 1687}
1395 OUTPUT: 1688 OUTPUT:
1396 RETVAL 1689 RETVAL
1397 1690
1398void 1691void
1399draw (CFPlus::Map self, int shift_x, int shift_y, int x0, int y0, int sw, int sh) 1692draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T)
1400 CODE: 1693 CODE:
1401{ 1694{
1402 int vx, vy; 1695 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1696 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1697 static uint8_t smooth_max[256][256]; // egad, fats and wasteful on memory (64k)
1698 smooth_key skey;
1403 int x, y, z; 1699 int x, y, z;
1404 int last_name; 1700 int last_name;
1405 mapface face;
1406 1701
1407 vx = self->x + self->w / 2 - sw / 2 - shift_x; 1702 // thats current max. sorry.
1408 vy = self->y + self->h / 2 - sh / 2 - shift_y; 1703 if (sw > 255) sw = 255;
1704 if (sh > 255) sh = 255;
1409 1705
1410 /* 1706 // clear key, in case of extra padding
1411 int vx = self->vx = self->w >= sw 1707 memset (&skey, 0, sizeof (skey));
1412 ? self->x + (self->w - sw) / 2
1413 : MIN (self->x, MAX (self->x + self->w - sw + 1, self->vx));
1414
1415 int vy = self->vy = self->h >= sh
1416 ? self->y + (self->h - sh) / 2
1417 : MIN (self->y, MAX (self->y + self->h - sh + 1, self->vy));
1418 */
1419 1708
1420 glColor4ub (255, 255, 255, 255); 1709 glColor4ub (255, 255, 255, 255);
1421 1710
1422 glEnable (GL_BLEND); 1711 glEnable (GL_BLEND);
1423 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 1712 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1426 1715
1427 glBegin (GL_QUADS); 1716 glBegin (GL_QUADS);
1428 1717
1429 last_name = 0; 1718 last_name = 0;
1430 1719
1720 mx += self->x;
1721 my += self->y;
1722
1723 // first pass: determine smooth_max
1724 // rather ugly, if you ask me
1725 // could also be stored inside mapcell and updated on change
1726 memset (smooth_max, 0, sizeof (smooth_max));
1727
1728 for (y = 0; y < sh; y++)
1729 if (0 <= y + my && y + my < self->rows)
1730 {
1731 maprow *row = self->row + (y + my);
1732
1733 for (x = 0; x < sw; x++)
1734 if (row->c0 <= x + mx && x + mx < row->c1)
1735 {
1736 mapcell *cell = row->col + (x + mx - row->c0);
1737
1738 smooth_max[x + 1][y + 1] =
1739 MAX (self->tex [cell->tile [0]].smoothlevel,
1740 MAX (self->tex [cell->tile [1]].smoothlevel,
1741 self->tex [cell->tile [2]].smoothlevel));
1742 }
1743 }
1744
1431 for (z = 0; z < 3; z++) 1745 for (z = 0; z <= 2; z++)
1746 {
1747 memset (smooth_level, 0, sizeof (smooth_level));
1748
1432 for (y = 0; y < sh; y++) 1749 for (y = 0; y < sh; y++)
1433 if (0 <= y + vy && y + vy < self->rows) 1750 if (0 <= y + my && y + my < self->rows)
1434 { 1751 {
1435 maprow *row = self->row + (y + vy); 1752 maprow *row = self->row + (y + my);
1436 1753
1437 for (x = 0; x < sw; x++) 1754 for (x = 0; x < sw; x++)
1438 if (row->c0 <= x + vx && x + vx < row->c1) 1755 if (row->c0 <= x + mx && x + mx < row->c1)
1439 { 1756 {
1440 mapcell *cell = row->col + (x + vx - row->c0); 1757 mapcell *cell = row->col + (x + mx - row->c0);
1441
1442 face = cell->face [z]; 1758 tileid tile = cell->tile [z];
1443 1759
1444 if (face) 1760 if (tile)
1761 {
1762 maptex tex = self->tex [tile];
1763 int px = (x + 1) * T - tex.w;
1764 int py = (y + 1) * T - tex.h;
1765
1766 // suppressing texture state switches here
1767 // is only moderately effective, but worth the extra effort
1768 if (last_name != tex.name)
1769 {
1770 if (!tex.name)
1771 tex = self->tex [2]; /* missing, replace by noface */
1772
1773 glEnd ();
1774 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1775 glBegin (GL_QUADS);
1776 }
1777
1778 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1779 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
1780 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1781 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1782
1783 if (cell->flags && z == 2)
1784 {
1785 if (cell->flags & 1)
1786 {
1787 maptex tex = self->tex [1];
1788 int px = x * T + T * 2 / 32;
1789 int py = y * T - T * 6 / 32;
1790
1791 glEnd ();
1792 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1793 glBegin (GL_QUADS);
1794
1795 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1796 glTexCoord2f (0 , tex.t); glVertex2f (px , py + T);
1797 glTexCoord2f (tex.s, tex.t); glVertex2f (px + T, py + T);
1798 glTexCoord2f (tex.s, 0 ); glVertex2f (px + T, py );
1799 }
1800 }
1801
1802 // update smooth hash
1803 if (tex.smoothtile)
1804 {
1805 skey.tile = tex.smoothtile;
1806 skey.level = tex.smoothlevel;
1807
1808 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31);
1809
1810 // add bits to current tile and all neighbours. skey.x|y is
1811 // shifted +1|+1 so we always stay positive.
1812
1813 // bits is ___n cccc CCCC bbbb
1814 // n do not draw borders&corners
1815 // c draw these corners, but...
1816 // C ... not these
1817 // b draw these borders
1818
1819 // borders: 1 ┃· 2 ━━ 4 ·┃ 8 ··
1820 // ┃· ·· ·┃ ━━
1821
1822 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
1823 // ·· ·· ·┏ ┓·
1824
1825 // full tile
1826 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000);
1827
1828 // borders
1829 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091);
1830 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032);
1831 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064);
1832 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8);
1833
1834 // corners
1835 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);
1836 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);
1837 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);
1838 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);
1839 }
1840 }
1841 }
1842 }
1843
1844 // go through all smoothlevels, lowest to highest, then draw.
1845 // this is basically counting sort
1846 {
1847 int w, b;
1848
1849 for (w = 0; w < 256 / 32; ++w)
1850 {
1851 uint32_t smask = smooth_level [w];
1852 if (smask)
1853 for (b = 0; b < 32; ++b)
1854 if (smask & (((uint32_t)1) << b))
1445 { 1855 {
1446 maptex tex = self->tex [face]; 1856 int level = (w << 5) | b;
1857 HE *he;
1447 1858
1448 int px = (x + 1) * 32 - tex.w; 1859 hv_iterinit (smooth);
1449 int py = (y + 1) * 32 - tex.h; 1860 while ((he = hv_iternext (smooth)))
1450
1451 if (last_name != tex.name)
1452 { 1861 {
1862 smooth_key *skey = (smooth_key *)HeKEY (he);
1863 IV bits = SvIVX (HeVAL (he));
1864
1865 if (!(bits & 0x1000)
1866 && skey->level == level
1867 && level > smooth_max [skey->x][skey->y])
1868 {
1869 maptex tex = self->tex [skey->tile];
1870 int px = (((int)skey->x) - 1) * T;
1871 int py = (((int)skey->y) - 1) * T;
1872 int border = bits & 15;
1873 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1874 float dx = tex.s * .0625f; // 16 images/row
1875 float dy = tex.t * .5f ; // 2 images/column
1876
1877 // this time naively avoiding texture state changes
1878 // save gobs of state changes.
1879 if (last_name != tex.name)
1880 {
1881 if (!tex.name)
1882 continue; // smoothing not yet available
1883
1453 glEnd (); 1884 glEnd ();
1454 last_name = tex.name;
1455 glBindTexture (GL_TEXTURE_2D, last_name); 1885 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1456 glBegin (GL_QUADS); 1886 glBegin (GL_QUADS);
1887 }
1888
1889 if (border)
1890 {
1891 float ox = border * dx;
1892
1893 glTexCoord2f (ox , 0.f ); glVertex2f (px , py );
1894 glTexCoord2f (ox , dy ); glVertex2f (px , py + T);
1895 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py + T);
1896 glTexCoord2f (ox + dx, 0.f ); glVertex2f (px + T, py );
1897 }
1898
1899 if (corner)
1900 {
1901 float ox = corner * dx;
1902
1903 glTexCoord2f (ox , dy ); glVertex2f (px , py );
1904 glTexCoord2f (ox , dy * 2.f); glVertex2f (px , py + T);
1905 glTexCoord2f (ox + dx, dy * 2.f); glVertex2f (px + T, py + T);
1906 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py );
1907 }
1908 }
1457 } 1909 }
1458
1459 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1460 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
1461 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1462 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1463 } 1910 }
1464 }
1465 } 1911 }
1912 }
1913
1914 hv_clear (smooth);
1915 }
1466 1916
1467 glEnd (); 1917 glEnd ();
1468 1918
1469 glDisable (GL_TEXTURE_2D); 1919 glDisable (GL_TEXTURE_2D);
1470 glDisable (GL_BLEND); 1920 glDisable (GL_BLEND);
1921
1922 // top layer: overlays such as the health bar
1923 for (y = 0; y < sh; y++)
1924 if (0 <= y + my && y + my < self->rows)
1925 {
1926 maprow *row = self->row + (y + my);
1927
1928 for (x = 0; x < sw; x++)
1929 if (row->c0 <= x + mx && x + mx < row->c1)
1930 {
1931 mapcell *cell = row->col + (x + mx - row->c0);
1932
1933 int px = x * T;
1934 int py = y * T;
1935
1936 if (cell->stat_hp)
1937 {
1938 int width = cell->stat_width * T;
1939 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
1940
1941 glColor3ub (0, 0, 0);
1942 glRectf (px + 1, py - thick - 2,
1943 px + width - 1, py);
1944
1945 glColor3ub (cell->stat_hp, 255 - cell->stat_hp, 0);
1946 glRectf (px + 2,
1947 py - thick - 1,
1948 px + width - 2 - cell->stat_hp * (width - 4) / 255, py - 1);
1949 }
1950 }
1951 }
1471} 1952}
1472 1953
1473void 1954void
1474draw_magicmap (CFPlus::Map self, int dx, int dy, int w, int h, unsigned char *data) 1955draw_magicmap (CFPlus::Map self, int dx, int dy, int w, int h, unsigned char *data)
1475 CODE: 1956 CODE:
1529 glDisable (GL_BLEND); 2010 glDisable (GL_BLEND);
1530 glDisable (GL_TEXTURE_2D); 2011 glDisable (GL_TEXTURE_2D);
1531} 2012}
1532 2013
1533void 2014void
1534fow_texture (CFPlus::Map self, int shift_x, int shift_y, int x0, int y0, int sw, int sh) 2015fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh)
1535 PPCODE: 2016 PPCODE:
1536{ 2017{
1537 int vx, vy;
1538 int x, y; 2018 int x, y;
2019 int sw1 = sw + 2;
2020 int sh1 = sh + 2;
2021 int sh3 = sh * 3;
1539 int sw4 = (sw + 3) & ~3; 2022 int sw34 = (sw * 3 + 3) & ~3;
2023 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
1540 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh)); 2024 SV *darkness3_sv = sv_2mortal (newSV (sw34 * sh3));
1541 uint8_t *darkness = (uint8_t *)SvPVX (darkness_sv); 2025 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
1542 2026
1543 memset (darkness, 255, sw4 * sh);
1544 SvPOK_only (darkness_sv); 2027 SvPOK_only (darkness3_sv);
1545 SvCUR_set (darkness_sv, sw4 * sh); 2028 SvCUR_set (darkness3_sv, sw34 * sh3);
1546 2029
1547 vx = self->x + (self->w - sw + 1) / 2 - shift_x; 2030 mx += self->x - 1;
1548 vy = self->y + (self->h - sh + 1) / 2 - shift_y; 2031 my += self->y - 1;
1549 2032
2033 memset (darkness1, 255, sw1 * sh1);
2034
1550 for (y = 0; y < sh; y++) 2035 for (y = 0; y < sh1; y++)
1551 if (0 <= y + vy && y + vy < self->rows) 2036 if (0 <= y + my && y + my < self->rows)
1552 { 2037 {
1553 maprow *row = self->row + (y + vy); 2038 maprow *row = self->row + (y + my);
1554 2039
1555 for (x = 0; x < sw; x++) 2040 for (x = 0; x < sw1; x++)
1556 if (row->c0 <= x + vx && x + vx < row->c1) 2041 if (row->c0 <= x + mx && x + mx < row->c1)
1557 { 2042 {
1558 mapcell *cell = row->col + (x + vx - row->c0); 2043 mapcell *cell = row->col + (x + mx - row->c0);
1559 2044
1560 darkness[y * sw4 + x] = cell->darkness < 0 2045 darkness1 [y * sw1 + x] = cell->darkness
2046 ? 255 - (cell->darkness - 1)
1561 ? 255 - FOW_DARKNESS 2047 : 255 - FOW_DARKNESS;
1562 : 255 - cell->darkness;
1563 } 2048 }
1564 } 2049 }
1565 2050
2051 for (y = 0; y < sh; ++y)
2052 for (x = 0; x < sw; ++x)
2053 {
2054 uint8_t d11 = darkness1 [(y ) * sw1 + x ];
2055 uint8_t d21 = darkness1 [(y ) * sw1 + x + 1];
2056 uint8_t d31 = darkness1 [(y ) * sw1 + x + 2];
2057 uint8_t d12 = darkness1 [(y + 1) * sw1 + x ];
2058 uint8_t d22 = darkness1 [(y + 1) * sw1 + x + 1];
2059 uint8_t d32 = darkness1 [(y + 1) * sw1 + x + 2];
2060 uint8_t d13 = darkness1 [(y + 2) * sw1 + x ];
2061 uint8_t d23 = darkness1 [(y + 2) * sw1 + x + 1];
2062 uint8_t d33 = darkness1 [(y + 2) * sw1 + x + 2];
2063
2064 uint8_t r11 = (d11 + d21 + d12) / 3;
2065 uint8_t r21 = d21;
2066 uint8_t r31 = (d21 + d31 + d32) / 3;
2067
2068 uint8_t r12 = d12;
2069 uint8_t r22 = d22;
2070 uint8_t r32 = d32;
2071
2072 uint8_t r13 = (d13 + d23 + d12) / 3;
2073 uint8_t r23 = d23;
2074 uint8_t r33 = (d23 + d33 + d32) / 3;
2075
2076 darkness3 [(y * 3 ) * sw34 + (x * 3 )] = MAX (d22, r11);
2077 darkness3 [(y * 3 ) * sw34 + (x * 3 + 1)] = MAX (d22, r21);
2078 darkness3 [(y * 3 ) * sw34 + (x * 3 + 2)] = MAX (d22, r31);
2079 darkness3 [(y * 3 + 1) * sw34 + (x * 3 )] = MAX (d22, r12);
2080 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 1)] = MAX (d22, r22);
2081 darkness3 [(y * 3 + 1) * sw34 + (x * 3 + 2)] = MAX (d22, r32);
2082 darkness3 [(y * 3 + 2) * sw34 + (x * 3 )] = MAX (d22, r13);
2083 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 1)] = MAX (d22, r23);
2084 darkness3 [(y * 3 + 2) * sw34 + (x * 3 + 2)] = MAX (d22, r33);
2085 }
2086
2087 free (darkness1);
2088
1566 EXTEND (SP, 3); 2089 EXTEND (SP, 3);
1567 PUSHs (sv_2mortal (newSViv (sw4))); 2090 PUSHs (sv_2mortal (newSViv (sw34)));
1568 PUSHs (sv_2mortal (newSViv (sh))); 2091 PUSHs (sv_2mortal (newSViv (sh3)));
1569 PUSHs (darkness_sv); 2092 PUSHs (darkness3_sv);
1570} 2093}
1571 2094
1572SV * 2095SV *
1573get_rect (CFPlus::Map self, int x0, int y0, int w, int h) 2096get_rect (CFPlus::Map self, int x0, int y0, int w, int h)
1574 CODE: 2097 CODE:
1603 if (row && row->c0 <= x && x < row->c1) 2126 if (row && row->c0 <= x && x < row->c1)
1604 { 2127 {
1605 mapcell *cell = row->col + (x - row->c0); 2128 mapcell *cell = row->col + (x - row->c0);
1606 uint8_t flags = 0; 2129 uint8_t flags = 0;
1607 2130
1608 if (cell->face [0]) flags |= 1; 2131 if (cell->tile [0]) flags |= 1;
1609 if (cell->face [1]) flags |= 2; 2132 if (cell->tile [1]) flags |= 2;
1610 if (cell->face [2]) flags |= 4; 2133 if (cell->tile [2]) flags |= 4;
1611 2134
1612 *data++ = flags; 2135 *data++ = flags;
1613 2136
1614 if (flags & 1) 2137 if (flags & 1)
1615 { 2138 {
2139 tileid tile = cell->tile [0];
1616 *data++ = cell->face [0] >> 8; 2140 *data++ = tile >> 8;
1617 *data++ = cell->face [0]; 2141 *data++ = tile;
1618 } 2142 }
1619 2143
1620 if (flags & 2) 2144 if (flags & 2)
1621 { 2145 {
2146 tileid tile = cell->tile [1];
1622 *data++ = cell->face [1] >> 8; 2147 *data++ = tile >> 8;
1623 *data++ = cell->face [1]; 2148 *data++ = tile;
1624 } 2149 }
1625 2150
1626 if (flags & 4) 2151 if (flags & 4)
1627 { 2152 {
2153 tileid tile = cell->tile [2];
1628 *data++ = cell->face [2] >> 8; 2154 *data++ = tile >> 8;
1629 *data++ = cell->face [2]; 2155 *data++ = tile;
1630 } 2156 }
1631 } 2157 }
1632 else 2158 else
1633 *data++ = 0; 2159 *data++ = 0;
1634 } 2160 }
1674 { 2200 {
1675 uint8_t flags = *data++; 2201 uint8_t flags = *data++;
1676 2202
1677 if (flags) 2203 if (flags)
1678 { 2204 {
1679 mapface face[3] = { 0, 0, 0 };
1680
1681 mapcell *cell = row_get_cell (row, x); 2205 mapcell *cell = row_get_cell (row, x);
2206 tileid tile[3] = { 0, 0, 0 };
1682 2207
1683 if (flags & 1) { face[0] = *data++ << 8; face[0] |= *data++; } 2208 if (flags & 1) { tile[0] = *data++ << 8; tile[0] |= *data++; }
1684 if (flags & 2) { face[1] = *data++ << 8; face[1] |= *data++; } 2209 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
1685 if (flags & 4) { face[2] = *data++ << 8; face[2] |= *data++; } 2210 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
1686 2211
1687 if (cell->darkness <= 0) 2212 if (cell->darkness == 0)
1688 { 2213 {
1689 cell->darkness = -1; 2214 cell->darkness = 0;
1690 2215
1691 for (z = 0; z <= 2; z++) 2216 for (z = 0; z <= 2; z++)
1692 { 2217 {
1693 cell->face[z] = face[z]; 2218 tileid t = tile [z];
1694 2219
1695 if (face[z] && (face[z] >= self->texs || !self->tex[face [z]].name)) 2220 if (t >= self->texs || (t && !self->tex [t].name))
2221 {
1696 XPUSHs (sv_2mortal (newSViv (face[z]))); 2222 XPUSHs (sv_2mortal (newSViv (t)));
2223 need_texid (self, t);
2224 }
2225
2226 cell->tile [z] = t;
1697 } 2227 }
1698 } 2228 }
1699 } 2229 }
1700 } 2230 }
1701 } 2231 }
1702} 2232}
1703 2233
1704MODULE = CFPlus PACKAGE = CFPlus::MixChunk 2234MODULE = CFPlus PACKAGE = CFPlus::MixChunk
1705 2235
2236PROTOTYPES: DISABLE
2237
1706CFPlus::MixChunk 2238CFPlus::MixChunk
1707new_from_file (SV *class, char *path) 2239new_from_file (SV *class, char *path)
1708 CODE: 2240 CODE:
1709 RETVAL = Mix_LoadWAV (path); 2241 RETVAL = Mix_LoadWAV (path);
1710 OUTPUT: 2242 OUTPUT:
1731 2263
1732MODULE = CFPlus PACKAGE = CFPlus::MixMusic 2264MODULE = CFPlus PACKAGE = CFPlus::MixMusic
1733 2265
1734int 2266int
1735volume (int volume = -1) 2267volume (int volume = -1)
2268 PROTOTYPE: ;$
1736 CODE: 2269 CODE:
1737 RETVAL = Mix_VolumeMusic (volume); 2270 RETVAL = Mix_VolumeMusic (volume);
1738 OUTPUT: 2271 OUTPUT:
1739 RETVAL 2272 RETVAL
1740 2273
2274int
2275fade_out (int ms)
2276 CODE:
2277 RETVAL = Mix_FadeOutMusic (ms);
2278 OUTPUT:
2279 RETVAL
2280
1741CFPlus::MixMusic 2281CFPlus::MixMusic
1742new_from_file (SV *class, char *path) 2282new_from_file (SV *class, char *path)
1743 CODE: 2283 CODE:
1744 RETVAL = Mix_LoadMUS (path); 2284 RETVAL = Mix_LoadMUS (path);
1745 OUTPUT: 2285 OUTPUT:
1755 CODE: 2295 CODE:
1756 RETVAL = Mix_PlayMusic (self, loops); 2296 RETVAL = Mix_PlayMusic (self, loops);
1757 OUTPUT: 2297 OUTPUT:
1758 RETVAL 2298 RETVAL
1759 2299
2300int
2301fade_in_pos (CFPlus::MixMusic self, int loops, int ms, double position)
2302 CODE:
2303 RETVAL = Mix_FadeInMusicPos (self, loops, ms, position);
2304 OUTPUT:
2305 RETVAL
2306
1760MODULE = CFPlus PACKAGE = CFPlus::OpenGL 2307MODULE = CFPlus PACKAGE = CFPlus::OpenGL
2308
2309PROTOTYPES: ENABLE
1761 2310
1762BOOT: 2311BOOT:
1763{ 2312{
1764 HV *stash = gv_stashpv ("CFPlus::OpenGL", 1); 2313 HV *stash = gv_stashpv ("CFPlus::OpenGL", 1);
1765 static const struct { 2314 static const struct {
1766 const char *name; 2315 const char *name;
1767 IV iv; 2316 IV iv;
1768 } *civ, const_iv[] = { 2317 } *civ, const_iv[] = {
1769# define const_iv(name) { # name, (IV)name } 2318# define const_iv(name) { # name, (IV)name }
2319 const_iv (GL_VENDOR),
2320 const_iv (GL_VERSION),
2321 const_iv (GL_EXTENSIONS),
1770 const_iv (GL_COLOR_MATERIAL), 2322 const_iv (GL_COLOR_MATERIAL),
1771 const_iv (GL_SMOOTH), 2323 const_iv (GL_SMOOTH),
1772 const_iv (GL_FLAT), 2324 const_iv (GL_FLAT),
1773 const_iv (GL_DITHER), 2325 const_iv (GL_DITHER),
1774 const_iv (GL_BLEND), 2326 const_iv (GL_BLEND),
1778 const_iv (GL_ALPHA_TEST), 2330 const_iv (GL_ALPHA_TEST),
1779 const_iv (GL_NORMALIZE), 2331 const_iv (GL_NORMALIZE),
1780 const_iv (GL_RESCALE_NORMAL), 2332 const_iv (GL_RESCALE_NORMAL),
1781 const_iv (GL_FRONT), 2333 const_iv (GL_FRONT),
1782 const_iv (GL_BACK), 2334 const_iv (GL_BACK),
2335 const_iv (GL_AUX0),
1783 const_iv (GL_AND), 2336 const_iv (GL_AND),
1784 const_iv (GL_ONE), 2337 const_iv (GL_ONE),
1785 const_iv (GL_ZERO), 2338 const_iv (GL_ZERO),
1786 const_iv (GL_SRC_ALPHA), 2339 const_iv (GL_SRC_ALPHA),
1787 const_iv (GL_DST_ALPHA), 2340 const_iv (GL_DST_ALPHA),
1801 const_iv (GL_LUMINANCE), 2354 const_iv (GL_LUMINANCE),
1802 const_iv (GL_LUMINANCE_ALPHA), 2355 const_iv (GL_LUMINANCE_ALPHA),
1803 const_iv (GL_FLOAT), 2356 const_iv (GL_FLOAT),
1804 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV), 2357 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV),
1805 const_iv (GL_COMPILE), 2358 const_iv (GL_COMPILE),
2359 const_iv (GL_PROXY_TEXTURE_1D),
2360 const_iv (GL_PROXY_TEXTURE_2D),
1806 const_iv (GL_TEXTURE_1D), 2361 const_iv (GL_TEXTURE_1D),
1807 const_iv (GL_TEXTURE_2D), 2362 const_iv (GL_TEXTURE_2D),
1808 const_iv (GL_TEXTURE_ENV), 2363 const_iv (GL_TEXTURE_ENV),
1809 const_iv (GL_TEXTURE_MAG_FILTER), 2364 const_iv (GL_TEXTURE_MAG_FILTER),
1810 const_iv (GL_TEXTURE_MIN_FILTER), 2365 const_iv (GL_TEXTURE_MIN_FILTER),
1831 const_iv (GL_COLOR_LOGIC_OP), 2386 const_iv (GL_COLOR_LOGIC_OP),
1832 const_iv (GL_SEPARABLE_2D), 2387 const_iv (GL_SEPARABLE_2D),
1833 const_iv (GL_CONVOLUTION_2D), 2388 const_iv (GL_CONVOLUTION_2D),
1834 const_iv (GL_CONVOLUTION_BORDER_MODE), 2389 const_iv (GL_CONVOLUTION_BORDER_MODE),
1835 const_iv (GL_CONSTANT_BORDER), 2390 const_iv (GL_CONSTANT_BORDER),
2391 const_iv (GL_POINTS),
1836 const_iv (GL_LINES), 2392 const_iv (GL_LINES),
1837 const_iv (GL_LINE_STRIP), 2393 const_iv (GL_LINE_STRIP),
1838 const_iv (GL_LINE_LOOP), 2394 const_iv (GL_LINE_LOOP),
1839 const_iv (GL_QUADS), 2395 const_iv (GL_QUADS),
1840 const_iv (GL_QUAD_STRIP), 2396 const_iv (GL_QUAD_STRIP),
1841 const_iv (GL_TRIANGLES), 2397 const_iv (GL_TRIANGLES),
1842 const_iv (GL_TRIANGLE_STRIP), 2398 const_iv (GL_TRIANGLE_STRIP),
1843 const_iv (GL_TRIANGLE_FAN), 2399 const_iv (GL_TRIANGLE_FAN),
2400 const_iv (GL_POLYGON),
1844 const_iv (GL_PERSPECTIVE_CORRECTION_HINT), 2401 const_iv (GL_PERSPECTIVE_CORRECTION_HINT),
2402 const_iv (GL_POINT_SMOOTH_HINT),
2403 const_iv (GL_LINE_SMOOTH_HINT),
2404 const_iv (GL_POLYGON_SMOOTH_HINT),
2405 const_iv (GL_GENERATE_MIPMAP_HINT),
1845 const_iv (GL_FASTEST), 2406 const_iv (GL_FASTEST),
2407 const_iv (GL_DONT_CARE),
2408 const_iv (GL_NICEST),
1846 const_iv (GL_V2F), 2409 const_iv (GL_V2F),
1847 const_iv (GL_V3F), 2410 const_iv (GL_V3F),
1848 const_iv (GL_T2F_V3F), 2411 const_iv (GL_T2F_V3F),
1849 const_iv (GL_T2F_N3F_V3F), 2412 const_iv (GL_T2F_N3F_V3F),
1850# undef const_iv 2413# undef const_iv
1851 }; 2414 };
1852 2415
1853 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 2416 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1854 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 2417 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
2418
2419 texture_av = newAV ();
2420 AvREAL_off (texture_av);
1855} 2421}
1856 2422
1857char * 2423char *
1858gl_vendor () 2424gl_vendor ()
1859 CODE: 2425 CODE:
1873 CODE: 2439 CODE:
1874 RETVAL = (char *)glGetString (GL_EXTENSIONS); 2440 RETVAL = (char *)glGetString (GL_EXTENSIONS);
1875 OUTPUT: 2441 OUTPUT:
1876 RETVAL 2442 RETVAL
1877 2443
2444const char *glGetString (GLenum pname)
2445
2446GLint glGetInteger (GLenum pname)
2447 CODE:
2448 glGetIntegerv (pname, &RETVAL);
2449 OUTPUT:
2450 RETVAL
2451
2452GLdouble glGetDouble (GLenum pname)
2453 CODE:
2454 glGetDoublev (pname, &RETVAL);
2455 OUTPUT:
2456 RETVAL
2457
1878int glGetError () 2458int glGetError ()
1879 2459
1880void glFinish () 2460void glFinish ()
1881 2461
1882void glClear (int mask) 2462void glClear (int mask)
1919# near_ and far_ are due to microsofts buggy "c" compiler 2499# near_ and far_ are due to microsofts buggy "c" compiler
1920void glFrustum (double left, double right, double bottom, double top, double near_, double far_) 2500void glFrustum (double left, double right, double bottom, double top, double near_, double far_)
1921 2501
1922# near_ and far_ are due to microsofts buggy "c" compiler 2502# near_ and far_ are due to microsofts buggy "c" compiler
1923void glOrtho (double left, double right, double bottom, double top, double near_, double far_) 2503void glOrtho (double left, double right, double bottom, double top, double near_, double far_)
2504
2505PROTOTYPES: DISABLE
1924 2506
1925void glViewport (int x, int y, int width, int height) 2507void glViewport (int x, int y, int width, int height)
1926 2508
1927void glScissor (int x, int y, int width, int height) 2509void glScissor (int x, int y, int width, int height)
1928 2510
1936 2518
1937void glRotate (float angle, float x, float y, float z) 2519void glRotate (float angle, float x, float y, float z)
1938 CODE: 2520 CODE:
1939 glRotatef (angle, x, y, z); 2521 glRotatef (angle, x, y, z);
1940 2522
1941void glBegin (int mode)
1942
1943void glEnd ()
1944
1945void glColor (float r, float g, float b, float a = 1.0) 2523void glColor (float r, float g, float b, float a = 1.0)
1946 PROTOTYPE: @
1947 ALIAS: 2524 ALIAS:
1948 glColor_premultiply = 1 2525 glColor_premultiply = 1
1949 CODE: 2526 CODE:
1950 if (ix) 2527 if (ix)
1951 { 2528 {
1954 b *= a; 2531 b *= a;
1955 } 2532 }
1956 // microsoft visual "c" rounds instead of truncating... 2533 // microsoft visual "c" rounds instead of truncating...
1957 glColor4f (r, g, b, a); 2534 glColor4f (r, g, b, a);
1958 2535
1959void glInterleavedArrays (int format, int stride, char *data)
1960
1961void glDrawElements (int mode, int count, int type, char *indices)
1962
1963# 1.2 void glDrawRangeElements (int mode, int start, int end
1964
1965void glRasterPos (float x, float y, float z = 0.) 2536void glRasterPos (float x, float y, float z = 0.)
1966 CODE: 2537 CODE:
1967 glRasterPos3f (0, 0, z); 2538 glRasterPos3f (0, 0, z);
1968 glBitmap (0, 0, 0, 0, x, y, 0); 2539 glBitmap (0, 0, 0, 0, x, y, 0);
1969 2540
1973 2544
1974void glTexCoord (float s, float t) 2545void glTexCoord (float s, float t)
1975 CODE: 2546 CODE:
1976 glTexCoord2f (s, t); 2547 glTexCoord2f (s, t);
1977 2548
2549PROTOTYPES: ENABLE
2550
2551void glBegin (int mode)
2552
2553void glEnd ()
2554
2555void glPointSize (GLfloat size)
2556
2557void glLineWidth (GLfloat width)
2558
2559void glInterleavedArrays (int format, int stride, char *data)
2560
2561void glDrawElements (int mode, int count, int type, char *indices)
2562
2563# 1.2 void glDrawRangeElements (int mode, int start, int end
2564
1978void glTexEnv (int target, int pname, float param) 2565void glTexEnv (int target, int pname, float param)
1979 CODE: 2566 CODE:
1980 glTexEnvf (target, pname, param); 2567 glTexEnvf (target, pname, param);
1981 2568
1982void glTexParameter (int target, int pname, float param) 2569void glTexParameter (int target, int pname, float param)
2004 2591
2005void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border) 2592void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
2006 2593
2007void glDrawPixels (int width, int height, int format, int type, char *pixels) 2594void glDrawPixels (int width, int height, int format, int type, char *pixels)
2008 2595
2596void glPixelZoom (float x, float y)
2597
2009void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR) 2598void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR)
2010 2599
2011int glGenTexture () 2600int glGenTexture ()
2012 CODE: 2601 CODE:
2013{ 2602 RETVAL = gen_texture ();
2014 GLuint name;
2015 glGenTextures (1, &name);
2016 RETVAL = name;
2017}
2018 OUTPUT: 2603 OUTPUT:
2019 RETVAL 2604 RETVAL
2020 2605
2021void glDeleteTexture (int name) 2606void glDeleteTexture (int name)
2022 CODE: 2607 CODE:
2023{
2024 GLuint name_ = name;
2025 glDeleteTextures (1, &name_); 2608 del_texture (name);
2026} 2609
2027
2028int glGenList () 2610int glGenList ()
2029 CODE: 2611 CODE:
2030 RETVAL = glGenLists (1); 2612 RETVAL = glGenLists (1);
2031 OUTPUT: 2613 OUTPUT:
2032 RETVAL 2614 RETVAL
2039 2621
2040void glEndList () 2622void glEndList ()
2041 2623
2042void glCallList (int list) 2624void glCallList (int list)
2043 2625
2626MODULE = CFPlus PACKAGE = CFPlus::UI::Base
2627
2628PROTOTYPES: DISABLE
2629
2630void
2631find_widget (SV *widget, NV x, NV y)
2632 PPCODE:
2633{
2634 if (within_widget (widget, x, y))
2635 XPUSHs (widget);
2636}
2637

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines