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.164 by root, Tue Nov 7 22:41:27 2006 UTC vs.
Revision 1.201 by root, Tue Jul 17 17:39:06 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# include <wininet.h>
7# pragma warning(disable:4244) 7# pragma warning(disable:4244)
8# pragma warning(disable:4761) 8# pragma warning(disable:4761)
9#endif 9#endif
10 10
11//#define DEBUG 1
12#if DEBUG
13# include <valgrind/memcheck.h>
14#endif
15
11#include "EXTERN.h" 16#include "EXTERN.h"
12#include "perl.h" 17#include "perl.h"
13#include "XSUB.h" 18#include "XSUB.h"
14 19
15#ifdef _WIN32 20#ifdef _WIN32
16# undef pipe 21# undef pipe
17#endif 22#endif
18 23
24#include <assert.h>
19#include <math.h> 25#include <math.h>
20#include <string.h> 26#include <string.h>
21#include <stdio.h> 27#include <stdio.h>
22#include <stdlib.h> 28#include <stdlib.h>
23 29
55# define PARACHUTE SDL_INIT_NOPARACHUTE 61# define PARACHUTE SDL_INIT_NOPARACHUTE
56#else 62#else
57# define PARACHUTE 0 63# define PARACHUTE 0
58#endif 64#endif
59 65
66static AV *texture_av;
67
60static struct 68static struct
61{ 69{
62#define GL_FUNC(ptr,name) ptr name; 70#define GL_FUNC(ptr,name) ptr name;
63#include "glfunc.h" 71#include "glfunc.h"
64#undef GL_FUNC 72#undef GL_FUNC
65} gl; 73} gl;
66 74
75static void
67static void gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa) 76gl_BlendFuncSeparate (GLenum sa, GLenum da, GLenum saa, GLenum daa)
68{ 77{
69 if (gl.BlendFuncSeparate) 78 if (gl.BlendFuncSeparate)
70 gl.BlendFuncSeparate (sa, da, saa, daa); 79 gl.BlendFuncSeparate (sa, da, saa, daa);
71 else if (gl.BlendFuncSeparateEXT) 80 else if (gl.BlendFuncSeparateEXT)
72 gl.BlendFuncSeparateEXT (sa, da, saa, daa); 81 gl.BlendFuncSeparateEXT (sa, da, saa, daa);
73 else 82 else
74 glBlendFunc (sa, da); 83 glBlendFunc (sa, da);
75} 84}
76 85
86static GLuint
87gen_texture ()
88{
89 GLuint name;
90
91 if (AvFILL (texture_av) >= 0)
92 name = (GLuint)(size_t)av_pop (texture_av);
93 else
94 glGenTextures (1, &name);
95
96 return name;
97}
98
99static void
100del_texture (GLuint name)
101{
102 /* make a half-assed attempt at returning the memory used by the texture */
103 /* textures are frequently being reused by cfplus anyway */
104 /*glBindTexture (GL_TEXTURE_2D, name);*/
105 /*glTexImage2D (GL_TEXTURE_2D, 0, GL_ALPHA, 0, 0, 0, GL_ALPHA, GL_UNSIGNED_BYTE, 0);*/
106 av_push (texture_av, (SV *)(size_t)name);
107 glDeleteTextures (1, &name);
108}
109
77#include "texcache.c" 110#include "texcache.c"
78 111
79#include "pango-font.c" 112#include "pango-font.c"
80#include "pango-fontmap.c" 113#include "pango-fontmap.c"
81#include "pango-render.c" 114#include "pango-render.c"
154 187
155 *w = rect.width; 188 *w = rect.width;
156 *h = rect.height; 189 *h = rect.height;
157} 190}
158 191
192typedef uint16_t tileid;
159typedef uint16_t mapface; 193typedef uint16_t faceid;
160 194
161typedef struct { 195typedef struct {
162 GLint name; 196 int name;
163 int w, h; 197 int w, h;
164 float s, t; 198 float s, t;
165 uint8_t r, g, b, a; 199 uint8_t r, g, b, a;
200 tileid smoothtile;
201 uint8_t smoothlevel;
166} maptex; 202} maptex;
167 203
168typedef struct { 204typedef struct {
169 uint32_t player; 205 uint32_t player;
170 mapface face[3]; 206 tileid tile[3];
171 uint16_t darkness; 207 uint16_t darkness;
172 uint8_t stat_width, stat_hp, flags; 208 uint8_t stat_width, stat_hp, flags, smoothmax;
173} mapcell; 209} mapcell;
174 210
175typedef struct { 211typedef struct {
176 int32_t c0, c1; 212 int32_t c0, c1;
177 mapcell *col; 213 mapcell *col;
178} maprow; 214} maprow;
179 215
180typedef struct map { 216typedef struct map {
181 int x, y, w, h; 217 int x, y, w, h;
182 int ox, oy; /* offset to virtual global coordinate system */ 218 int ox, oy; /* offset to virtual global coordinate system */
183 int faces; 219 int faces; tileid *face2tile; // [faceid]
184 mapface *face; 220 int texs; maptex *tex; // [tileid]
185
186 int texs;
187 maptex *tex;
188 221
189 int32_t rows; 222 int32_t rows;
190 maprow *row; 223 maprow *row;
191} *CFPlus__Map; 224} *CFPlus__Map;
192 225
212 return ptr; 245 return ptr;
213} 246}
214 247
215#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type)) 248#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
216#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type)) 249#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
250
251static void
252need_facenum (struct map *self, faceid face)
253{
254 while (self->faces <= face)
255 {
256 Append (tileid, self->face2tile, self->faces, self->faces);
257 self->faces *= 2;
258 }
259}
260
261static void
262need_texid (struct map *self, int texid)
263{
264 while (self->texs <= texid)
265 {
266 Append (maptex, self->tex, self->texs, self->texs);
267 self->texs *= 2;
268 }
269}
217 270
218static maprow * 271static maprow *
219map_get_row (CFPlus__Map self, int y) 272map_get_row (CFPlus__Map self, int y)
220{ 273{
221 if (0 > y) 274 if (0 > y)
316 cell->player = 0; 369 cell->player = 0;
317 } 370 }
318 } 371 }
319} 372}
320 373
374typedef struct {
375 tileid tile;
376 uint8_t x, y, level;
377} smooth_key;
378
379static void
380smooth_or_bits (HV *hv, smooth_key *key, IV bits)
381{
382 SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1);
383
384 if (SvIOK (*sv))
385 SvIV_set (*sv, SvIVX (*sv) | bits);
386 else
387 sv_setiv (*sv, bits);
388}
389
321static void 390static void
322music_finished (void) 391music_finished (void)
323{ 392{
324 SDL_UserEvent ev; 393 SDL_UserEvent ev;
325 394
358 n |= n >> 8; 427 n |= n >> 8;
359 n |= n >> 16; 428 n |= n >> 16;
360 429
361 return n + 1; 430 return n + 1;
362} 431}
432
433/* SDL should provide this, really. */
434#define SDLK_MODIFIER_MIN 300
435#define SDLK_MODIFIER_MAX 314
363 436
364MODULE = CFPlus PACKAGE = CFPlus 437MODULE = CFPlus PACKAGE = CFPlus
365 438
366PROTOTYPES: ENABLE 439PROTOTYPES: ENABLE
367 440
371 static const struct { 444 static const struct {
372 const char *name; 445 const char *name;
373 IV iv; 446 IV iv;
374 } *civ, const_iv[] = { 447 } *civ, const_iv[] = {
375# define const_iv(name) { # name, (IV)name } 448# define const_iv(name) { # name, (IV)name }
449 const_iv (SDLK_MODIFIER_MIN),
450 const_iv (SDLK_MODIFIER_MAX),
451
376 const_iv (SDL_ACTIVEEVENT), 452 const_iv (SDL_ACTIVEEVENT),
377 const_iv (SDL_KEYDOWN), 453 const_iv (SDL_KEYDOWN),
378 const_iv (SDL_KEYUP), 454 const_iv (SDL_KEYUP),
379 const_iv (SDL_MOUSEMOTION), 455 const_iv (SDL_MOUSEMOTION),
380 const_iv (SDL_MOUSEBUTTONDOWN), 456 const_iv (SDL_MOUSEBUTTONDOWN),
389 const_iv (SDL_EVENT_RESERVEDA), 465 const_iv (SDL_EVENT_RESERVEDA),
390 const_iv (SDL_EVENT_RESERVEDB), 466 const_iv (SDL_EVENT_RESERVEDB),
391 const_iv (SDL_VIDEORESIZE), 467 const_iv (SDL_VIDEORESIZE),
392 const_iv (SDL_VIDEOEXPOSE), 468 const_iv (SDL_VIDEOEXPOSE),
393 const_iv (SDL_USEREVENT), 469 const_iv (SDL_USEREVENT),
470
471 const_iv (SDL_APPINPUTFOCUS),
472 const_iv (SDL_APPMOUSEFOCUS),
473 const_iv (SDL_APPACTIVE),
474
394 const_iv (SDLK_KP0), 475 const_iv (SDLK_KP0),
395 const_iv (SDLK_KP1), 476 const_iv (SDLK_KP1),
396 const_iv (SDLK_KP2), 477 const_iv (SDLK_KP2),
397 const_iv (SDLK_KP3), 478 const_iv (SDLK_KP3),
398 const_iv (SDLK_KP4), 479 const_iv (SDLK_KP4),
453 const_iv (SDLK_BREAK), 534 const_iv (SDLK_BREAK),
454 const_iv (SDLK_MENU), 535 const_iv (SDLK_MENU),
455 const_iv (SDLK_POWER), 536 const_iv (SDLK_POWER),
456 const_iv (SDLK_EURO), 537 const_iv (SDLK_EURO),
457 const_iv (SDLK_UNDO), 538 const_iv (SDLK_UNDO),
539
458 const_iv (KMOD_NONE), 540 const_iv (KMOD_NONE),
541 const_iv (KMOD_SHIFT),
459 const_iv (KMOD_LSHIFT), 542 const_iv (KMOD_LSHIFT),
460 const_iv (KMOD_RSHIFT), 543 const_iv (KMOD_RSHIFT),
544 const_iv (KMOD_CTRL),
461 const_iv (KMOD_LCTRL), 545 const_iv (KMOD_LCTRL),
462 const_iv (KMOD_RCTRL), 546 const_iv (KMOD_RCTRL),
547 const_iv (KMOD_ALT),
463 const_iv (KMOD_LALT), 548 const_iv (KMOD_LALT),
464 const_iv (KMOD_RALT), 549 const_iv (KMOD_RALT),
550 const_iv (KMOD_META),
465 const_iv (KMOD_LMETA), 551 const_iv (KMOD_LMETA),
466 const_iv (KMOD_RMETA), 552 const_iv (KMOD_RMETA),
467 const_iv (KMOD_NUM), 553 const_iv (KMOD_NUM),
468 const_iv (KMOD_CAPS), 554 const_iv (KMOD_CAPS),
469 const_iv (KMOD_MODE), 555 const_iv (KMOD_MODE),
470 const_iv (KMOD_CTRL),
471 const_iv (KMOD_SHIFT),
472 const_iv (KMOD_ALT),
473 const_iv (KMOD_META)
474# undef const_iv 556# undef const_iv
475 }; 557 };
476 558
477 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 559 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
478 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 560 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
561
562 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
563 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
479} 564}
565
566void
567weaken (SV *rv)
568 PROTOTYPE: $
569 CODE:
570 sv_rvweaken (rv);
480 571
481int 572int
482in_destruct () 573in_destruct ()
483 CODE: 574 CODE:
484 RETVAL = PL_main_cv == Nullcv; 575 RETVAL = PL_main_cv == Nullcv;
496 opengl_fontmap = pango_opengl_font_map_new (); 587 opengl_fontmap = pango_opengl_font_map_new ();
497 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0); 588 pango_opengl_font_map_set_default_substitute ((PangoOpenGLFontMap *)opengl_fontmap, substitute_func, 0, 0);
498 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap); 589 opengl_context = pango_opengl_font_map_create_context ((PangoOpenGLFontMap *)opengl_fontmap);
499} 590}
500 591
592char *
593SDL_GetError ()
594
501int 595int
502SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE) 596SDL_Init (U32 flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | PARACHUTE)
503 597
504void 598void
505SDL_Quit () 599SDL_Quit ()
506 600
507void 601void
508SDL_ListModes () 602SDL_ListModes (int rgb, int alpha)
509 PPCODE: 603 PPCODE:
510{ 604{
511 SDL_Rect **m; 605 SDL_Rect **m;
512 606
513 SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5); 607 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
514 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5); 608 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
515 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5); 609 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
516 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 1); 610 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
517 611
518 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15); 612 SDL_GL_SetAttribute (SDL_GL_BUFFER_SIZE, 15);
519 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 0); 613 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE , 0);
520 614
521 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE, 0); 615 SDL_GL_SetAttribute (SDL_GL_ACCUM_RED_SIZE , 0);
522 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0); 616 SDL_GL_SetAttribute (SDL_GL_ACCUM_GREEN_SIZE, 0);
523 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE, 0); 617 SDL_GL_SetAttribute (SDL_GL_ACCUM_BLUE_SIZE , 0);
524 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0); 618 SDL_GL_SetAttribute (SDL_GL_ACCUM_ALPHA_SIZE, 0);
525 619
526 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); 620 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
527#if SDL_VERSION_ATLEAST(1,2,10) 621#if SDL_VERSION_ATLEAST(1,2,10)
528 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1); 622 SDL_GL_SetAttribute (SDL_GL_ACCELERATED_VISUAL, 1);
529 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1); 623 SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 1);
530#endif 624#endif
531 625
532 SDL_EnableUNICODE (1);
533 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
534
535 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL); 626 m = SDL_ListModes (0, SDL_FULLSCREEN | SDL_OPENGL);
536 627
537 if (m && m != (SDL_Rect **)-1) 628 if (m && m != (SDL_Rect **)-1)
538 while (*m) 629 while (*m)
539 { 630 {
631 if ((*m)->w >= 640 && (*m)->h >= 480)
632 {
540 AV *av = newAV (); 633 AV *av = newAV ();
541 av_push (av, newSViv ((*m)->w)); 634 av_push (av, newSViv ((*m)->w));
542 av_push (av, newSViv ((*m)->h)); 635 av_push (av, newSViv ((*m)->h));
636 av_push (av, newSViv (rgb));
637 av_push (av, newSViv (alpha));
543 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av))); 638 XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
639 }
544 640
545 ++m; 641 ++m;
546 } 642 }
547} 643}
548 644
549char *
550SDL_GetError ()
551
552int 645int
553SDL_SetVideoMode (int w, int h, int fullscreen) 646SDL_SetVideoMode (int w, int h, int rgb, int alpha, int fullscreen)
554 CODE: 647 CODE:
648{
649 SDL_EnableUNICODE (1);
650 SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
651
652 SDL_GL_SetAttribute (SDL_GL_RED_SIZE , rgb);
653 SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, rgb);
654 SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE , rgb);
655 SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, alpha);
656
555 RETVAL = !!SDL_SetVideoMode ( 657 RETVAL = !!SDL_SetVideoMode (
556 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0) 658 w, h, 0, SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0)
557 ); 659 );
660
558 if (RETVAL) 661 if (RETVAL)
559 { 662 {
663 av_clear (texture_av);
664
560 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+"); 665 SDL_WM_SetCaption ("Crossfire+ Client " VERSION, "Crossfire+");
561# define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name); 666#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
562# include "glfunc.h" 667#include "glfunc.h"
563# undef GL_FUNC 668#undef GL_FUNC
564 } 669 }
670}
565 OUTPUT: 671 OUTPUT:
566 RETVAL 672 RETVAL
567 673
568void 674void
569SDL_GL_SwapBuffers () 675SDL_GL_SwapBuffers ()
570 676
571char * 677char *
572SDL_GetKeyName (int sym) 678SDL_GetKeyName (int sym)
573 679
680int
681SDL_GetAppState ()
682
574void 683void
575SDL_PollEvent () 684poll_events ()
576 PPCODE: 685 PPCODE:
577{ 686{
578 SDL_Event ev; 687 SDL_Event ev;
579 688
580 while (SDL_PollEvent (&ev)) 689 SDL_PumpEvents ();
690 while (SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_ALLEVENTS) > 0)
581 { 691 {
582 HV *hv = newHV (); 692 HV *hv = newHV ();
583 hv_store (hv, "type", 4, newSViv (ev.type), 0); 693 hv_store (hv, "type", 4, newSViv (ev.type), 0);
584 694
585 switch (ev.type) 695 switch (ev.type)
587 case SDL_KEYDOWN: 697 case SDL_KEYDOWN:
588 case SDL_KEYUP: 698 case SDL_KEYUP:
589 hv_store (hv, "state", 5, newSViv (ev.key.state), 0); 699 hv_store (hv, "state", 5, newSViv (ev.key.state), 0);
590 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0); 700 hv_store (hv, "sym", 3, newSViv (ev.key.keysym.sym), 0);
591 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0); 701 hv_store (hv, "mod", 3, newSViv (ev.key.keysym.mod), 0);
702 hv_store (hv, "cmod", 4, newSViv (SDL_GetModState ()), 0); /* current mode */
592 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0); 703 hv_store (hv, "unicode", 7, newSViv (ev.key.keysym.unicode), 0);
593 break; 704 break;
594 705
595 case SDL_ACTIVEEVENT: 706 case SDL_ACTIVEEVENT:
596 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0); 707 hv_store (hv, "gain", 4, newSViv (ev.active.gain), 0);
597 hv_store (hv, "state", 5, newSViv (ev.active.state), 0); 708 hv_store (hv, "state", 5, newSViv (ev.active.state), 0);
598 break; 709 break;
599 710
600 case SDL_MOUSEMOTION: 711 case SDL_MOUSEMOTION:
712 {
713 int state = ev.motion.state;
714 int x = ev.motion.x;
715 int y = ev.motion.y;
716 int xrel = ev.motion.xrel;
717 int yrel = ev.motion.yrel;
718
719 /* do simplistic event compression */
720 while (SDL_PeepEvents (&ev, 1, SDL_PEEKEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION)) > 0
721 && state == ev.motion.state)
722 {
723 xrel += ev.motion.xrel;
724 yrel += ev.motion.yrel;
725 x = ev.motion.x;
726 y = ev.motion.y;
727 SDL_PeepEvents (&ev, 1, SDL_GETEVENT, SDL_EVENTMASK (SDL_MOUSEMOTION));
728 }
729
601 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 730 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);
602
603 hv_store (hv, "state", 5, newSViv (ev.motion.state), 0); 731 hv_store (hv, "state", 5, newSViv (state), 0);
604 hv_store (hv, "x", 1, newSViv (ev.motion.x), 0); 732 hv_store (hv, "x", 1, newSViv (x), 0);
605 hv_store (hv, "y", 1, newSViv (ev.motion.y), 0); 733 hv_store (hv, "y", 1, newSViv (y), 0);
606 hv_store (hv, "xrel", 4, newSViv (ev.motion.xrel), 0); 734 hv_store (hv, "xrel", 4, newSViv (xrel), 0);
607 hv_store (hv, "yrel", 4, newSViv (ev.motion.yrel), 0); 735 hv_store (hv, "yrel", 4, newSViv (yrel), 0);
736 }
608 break; 737 break;
609 738
610 case SDL_MOUSEBUTTONDOWN: 739 case SDL_MOUSEBUTTONDOWN:
611 case SDL_MOUSEBUTTONUP: 740 case SDL_MOUSEBUTTONUP:
612 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0); 741 hv_store (hv, "mod", 3, newSViv (SDL_GetModState ()), 0);
641Mix_AllocateChannels (int numchans = -1) 770Mix_AllocateChannels (int numchans = -1)
642 771
643void 772void
644lowdelay (int fd, int val = 1) 773lowdelay (int fd, int val = 1)
645 CODE: 774 CODE:
646#ifndef _WIN32
647 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof (val)); 775 setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (void *)&val, sizeof (val));
648#endif
649 776
650void 777void
651win32_proxy_info () 778win32_proxy_info ()
652 PPCODE: 779 PPCODE:
653{ 780{
794 ExitThread (retval); // unclean, please beam me up 921 ExitThread (retval); // unclean, please beam me up
795#else 922#else
796 _exit (retval); 923 _exit (retval);
797#endif 924#endif
798 925
926void
927debug ()
928 CODE:
929{
930#if DEBUG
931 VALGRIND_DO_LEAK_CHECK;
932#endif
933}
934
799MODULE = CFPlus PACKAGE = CFPlus::Font 935MODULE = CFPlus PACKAGE = CFPlus::Font
800 936
801CFPlus::Font 937CFPlus::Font
802new_from_file (SV *class, char *path, int id = 0) 938new_from_file (SV *class, char *path, int id = 0)
803 CODE: 939 CODE:
1049xy_to_index (CFPlus::Layout self, int x, int y) 1185xy_to_index (CFPlus::Layout self, int x, int y)
1050 CODE: 1186 CODE:
1051{ 1187{
1052 int index, trailing; 1188 int index, trailing;
1053 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing); 1189 pango_layout_xy_to_index (self->pl, x * PANGO_SCALE, y * PANGO_SCALE, &index, &trailing);
1054 RETVAL = index; 1190 RETVAL = index + trailing;
1055} 1191}
1056 OUTPUT: 1192 OUTPUT:
1057 RETVAL 1193 RETVAL
1058 1194
1059void 1195void
1065 1201
1066 EXTEND (SP, 3); 1202 EXTEND (SP, 3);
1067 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE))); 1203 PUSHs (sv_2mortal (newSViv (strong_pos.x / PANGO_SCALE)));
1068 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE))); 1204 PUSHs (sv_2mortal (newSViv (strong_pos.y / PANGO_SCALE)));
1069 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE))); 1205 PUSHs (sv_2mortal (newSViv (strong_pos.height / PANGO_SCALE)));
1206}
1207
1208void
1209index_to_line_x (CFPlus::Layout self, int index, int trailing = 0)
1210 PPCODE:
1211{
1212 int line, x;
1213
1214 pango_layout_index_to_line_x (self->pl, index, trailing, &line, &x);
1215 /* pango bug: line is between 1..numlines, not 0..numlines-1 */
1216
1217 EXTEND (SP, 2);
1218 PUSHs (sv_2mortal (newSViv (line - 1)));
1219 PUSHs (sv_2mortal (newSViv (x / PANGO_SCALE)));
1220}
1221
1222void
1223line_x_to_index (CFPlus::Layout self, int line, int x)
1224 PPCODE:
1225{
1226 PangoLayoutLine *lp;
1227 int index, trailing;
1228
1229 if (line < 0)
1230 XSRETURN_EMPTY;
1231
1232 if (!(lp = pango_layout_get_line (self->pl, line)))
1233 XSRETURN_EMPTY; /* do better */
1234
1235 pango_layout_line_x_to_index (lp, x * PANGO_SCALE, &index, &trailing);
1236
1237 EXTEND (SP, 2);
1238 if (GIMME_V == G_SCALAR)
1239 PUSHs (sv_2mortal (newSViv (index + trailing)));
1240 else
1241 {
1242 PUSHs (sv_2mortal (newSViv (index)));
1243 PUSHs (sv_2mortal (newSViv (trailing)));
1244 }
1070} 1245}
1071 1246
1072void 1247void
1073render (CFPlus::Layout self, float x, float y, int flags = 0) 1248render (CFPlus::Layout self, float x, float y, int flags = 0)
1074 PPCODE: 1249 PPCODE:
1079 flags 1254 flags
1080 ); 1255 );
1081 1256
1082MODULE = CFPlus PACKAGE = CFPlus::Texture 1257MODULE = CFPlus PACKAGE = CFPlus::Texture
1083 1258
1259int minpot (int n)
1260
1084void 1261void
1085pad2pot (SV *data_, SV *w_, SV *h_) 1262pad2pot (SV *data_, SV *w_, SV *h_)
1086 CODE: 1263 CODE:
1087{ 1264{
1088 int ow = SvIV (w_); 1265 int ow = SvIV (w_);
1165 glDisable (GL_ALPHA_TEST); 1342 glDisable (GL_ALPHA_TEST);
1166 glDisable (GL_BLEND); 1343 glDisable (GL_BLEND);
1167 } 1344 }
1168} 1345}
1169 1346
1347IV texture_valid_2d (GLint internalformat, GLsizei w, GLsizei h, GLenum format, GLenum type)
1348 CODE:
1349{
1350 GLint width;
1351 glTexImage2D (GL_PROXY_TEXTURE_2D, 0, internalformat, w, h, 0, format, type, 0);
1352 glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
1353 RETVAL = width > 0;
1354}
1355 OUTPUT:
1356 RETVAL
1357
1170MODULE = CFPlus PACKAGE = CFPlus::Map 1358MODULE = CFPlus PACKAGE = CFPlus::Map
1171 1359
1172CFPlus::Map 1360CFPlus::Map
1173new (SV *class) 1361new (SV *class)
1174 CODE: 1362 CODE:
1177 RETVAL->y = 0; 1365 RETVAL->y = 0;
1178 RETVAL->w = 0; 1366 RETVAL->w = 0;
1179 RETVAL->h = 0; 1367 RETVAL->h = 0;
1180 RETVAL->ox = 0; 1368 RETVAL->ox = 0;
1181 RETVAL->oy = 0; 1369 RETVAL->oy = 0;
1182 RETVAL->faces = 8192; 1370 RETVAL->faces = 8192; Newz (0, RETVAL->face2tile, RETVAL->faces, tileid);
1183 Newz (0, RETVAL->face, RETVAL->faces, mapface); 1371 RETVAL->texs = 8192; Newz (0, RETVAL->tex , RETVAL->texs , maptex);
1184 RETVAL->texs = 8192;
1185 Newz (0, RETVAL->tex, RETVAL->texs, maptex);
1186 RETVAL->rows = 0; 1372 RETVAL->rows = 0;
1187 RETVAL->row = 0; 1373 RETVAL->row = 0;
1188 OUTPUT: 1374 OUTPUT:
1189 RETVAL 1375 RETVAL
1190 1376
1191void 1377void
1192DESTROY (CFPlus::Map self) 1378DESTROY (CFPlus::Map self)
1193 CODE: 1379 CODE:
1194{ 1380{
1195 map_clear (self); 1381 map_clear (self);
1196 Safefree (self->face); 1382 Safefree (self->face2tile);
1197 Safefree (self->tex); 1383 Safefree (self->tex);
1198 Safefree (self); 1384 Safefree (self);
1199} 1385}
1200 1386
1201void 1387void
1208clear (CFPlus::Map self) 1394clear (CFPlus::Map self)
1209 CODE: 1395 CODE:
1210 map_clear (self); 1396 map_clear (self);
1211 1397
1212void 1398void
1213set_face (CFPlus::Map self, int face, int texid) 1399set_tileid (CFPlus::Map self, int face, int tile)
1214 CODE: 1400 CODE:
1215{ 1401{
1216 while (self->faces <= face) 1402 need_facenum (self, face); self->face2tile [face] = tile;
1217 { 1403 need_texid (self, tile);
1218 Append (mapface, self->face, self->faces, self->faces); 1404}
1219 self->faces *= 2;
1220 }
1221 1405
1222 self->face [face] = texid; 1406void
1407set_smooth (CFPlus::Map self, int face, int smooth, int level)
1408 CODE:
1409{
1410 tileid texid;
1411 maptex *tex;
1412
1413 if (face < 0 || face >= self->faces)
1414 return;
1415
1416 if (smooth < 0 || smooth >= self->faces)
1417 return;
1418
1419 texid = self->face2tile [face];
1420
1421 if (!texid)
1422 return;
1423
1424 tex = self->tex + texid;
1425 tex->smoothtile = self->face2tile [smooth];
1426 tex->smoothlevel = level;
1223} 1427}
1224 1428
1225void 1429void
1226set_texture (CFPlus::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a) 1430set_texture (CFPlus::Map self, int texid, int name, int w, int h, float s, float t, int r, int g, int b, int a)
1227 CODE: 1431 CODE:
1228{ 1432{
1229 while (self->texs <= texid) 1433 need_texid (self, texid);
1230 {
1231 Append (maptex, self->tex, self->texs, self->texs);
1232 self->texs *= 2;
1233 }
1234 1434
1235 { 1435 {
1236 maptex *tex = self->tex + texid; 1436 maptex *tex = self->tex + texid;
1237 1437
1238 tex->name = name; 1438 tex->name = name;
1282 CODE: 1482 CODE:
1283{ 1483{
1284 if (dx > 0) 1484 if (dx > 0)
1285 map_blank (self, self->x, self->y, dx, self->h); 1485 map_blank (self, self->x, self->y, dx, self->h);
1286 else if (dx < 0) 1486 else if (dx < 0)
1287 map_blank (self, self->x + self->w + dx + 1, self->y, -dx, self->h); 1487 map_blank (self, self->x + self->w + dx, self->y, -dx, self->h);
1288 1488
1289 if (dy > 0) 1489 if (dy > 0)
1290 map_blank (self, self->x, self->y, self->w, dy); 1490 map_blank (self, self->x, self->y, self->w, dy);
1291 else if (dy < 0) 1491 else if (dy < 0)
1292 map_blank (self, self->x, self->y + self->h + dy + 1, self->w, -dy); 1492 map_blank (self, self->x, self->y + self->h + dy, self->w, -dy);
1293 1493
1294 self->ox += dx; self->x += dx; 1494 self->ox += dx; self->x += dx;
1295 self->oy += dy; self->y += dy; 1495 self->oy += dy; self->y += dy;
1296 1496
1297 while (self->y < 0) 1497 while (self->y < 0)
1349 cell->stat_width = 1; 1549 cell->stat_width = 1;
1350 cell->stat_hp = *data++; 1550 cell->stat_hp = *data++;
1351 } 1551 }
1352 else if (cmd == 6) // monster width 1552 else if (cmd == 6) // monster width
1353 cell->stat_width = *data++ + 1; 1553 cell->stat_width = *data++ + 1;
1354 else if (cmd == 0x47) // monster width 1554 else if (cmd == 0x47)
1355 { 1555 {
1356 if (*data == 4) 1556 if (*data == 4)
1357 ; // decode player tag 1557 ; // decode player count
1358 1558
1359 data += *data + 1; 1559 data += *data + 1;
1360 } 1560 }
1361 else if (cmd == 8) // cell flags 1561 else if (cmd == 8) // cell flags
1362 cell->flags = *data++; 1562 cell->flags = *data++;
1371 cell->darkness = *data++ + 1; 1571 cell->darkness = *data++ + 1;
1372 } 1572 }
1373 1573
1374 if (flags & 4) 1574 if (flags & 4)
1375 { 1575 {
1376 cell->face [0] = 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 [0] = self->face2tile [face];
1377 } 1579 }
1378 1580
1379 if (flags & 2) 1581 if (flags & 2)
1380 { 1582 {
1381 cell->face [1] = self->face [(data [0] << 8) + data [1]]; data += 2; 1583 faceid face = (data [0] << 8) + data [1]; data += 2;
1584 need_facenum (self, face);
1585 cell->tile [1] = self->face2tile [face];
1382 } 1586 }
1383 1587
1384 if (flags & 1) 1588 if (flags & 1)
1385 { 1589 {
1386 cell->face [2] = self->face [(data [0] << 8) + data [1]]; data += 2; 1590 faceid face = (data [0] << 8) + data [1]; data += 2;
1591 need_facenum (self, face);
1592 cell->tile [2] = self->face2tile [face];
1387 } 1593 }
1388 } 1594 }
1389 else 1595 else
1390 cell->darkness = 0; 1596 cell->darkness = 0;
1391 } 1597 }
1421 { 1627 {
1422 mapcell *cell = row->col + (x - row->c0); 1628 mapcell *cell = row->col + (x - row->c0);
1423 1629
1424 for (z = 0; z <= 0; z++) 1630 for (z = 0; z <= 0; z++)
1425 { 1631 {
1426 mapface face = cell->face [z];
1427
1428 if (face)
1429 {
1430 maptex tex = self->tex [face]; 1632 maptex tex = self->tex [cell->tile [z]];
1431 int a0 = 255 - tex.a; 1633 int a0 = 255 - tex.a;
1432 int a1 = tex.a; 1634 int a1 = tex.a;
1433 1635
1434 r = (r * a0 + tex.r * a1) / 255; 1636 r = (r * a0 + tex.r * a1) / 255;
1435 g = (g * a0 + tex.g * a1) / 255; 1637 g = (g * a0 + tex.g * a1) / 255;
1436 b = (b * a0 + tex.b * a1) / 255; 1638 b = (b * a0 + tex.b * a1) / 255;
1437 a = (a * a0 + tex.a * a1) / 255; 1639 a = (a * a0 + tex.a * a1) / 255;
1438 }
1439 } 1640 }
1440 } 1641 }
1441 1642
1442 *map++ = (r ) 1643 *map++ = (r )
1443 | (g << 8) 1644 | (g << 8)
1450} 1651}
1451 OUTPUT: 1652 OUTPUT:
1452 RETVAL 1653 RETVAL
1453 1654
1454void 1655void
1455draw (CFPlus::Map self, int mx, int my, int sw, int sh) 1656draw (CFPlus::Map self, int mx, int my, int sw, int sh, int T)
1456 CODE: 1657 CODE:
1457{ 1658{
1659 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
1660 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
1661 static uint8_t smooth_max[256][256]; // egad, fats and wasteful on memory (64k)
1662 smooth_key skey;
1458 int x, y, z; 1663 int x, y, z;
1459 int last_name; 1664 int last_name;
1460 mapface face; 1665
1666 // thats current max. sorry.
1667 if (sw > 255) sw = 255;
1668 if (sh > 255) sh = 255;
1669
1670 // clear key, in case of extra padding
1671 memset (&skey, 0, sizeof (skey));
1461 1672
1462 glColor4ub (255, 255, 255, 255); 1673 glColor4ub (255, 255, 255, 255);
1463 1674
1464 glEnable (GL_BLEND); 1675 glEnable (GL_BLEND);
1465 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 1676 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1471 last_name = 0; 1682 last_name = 0;
1472 1683
1473 mx += self->x; 1684 mx += self->x;
1474 my += self->y; 1685 my += self->y;
1475 1686
1687 // first pass: determine smooth_max
1688 // rather ugly, if you ask me
1689 // could also be stored inside mapcell and updated on change
1690 memset (smooth_max, 0, sizeof (smooth_max));
1691
1692 for (y = 0; y < sh; y++)
1693 if (0 <= y + my && y + my < self->rows)
1694 {
1695 maprow *row = self->row + (y + my);
1696
1697 for (x = 0; x < sw; x++)
1698 if (row->c0 <= x + mx && x + mx < row->c1)
1699 {
1700 mapcell *cell = row->col + (x + mx - row->c0);
1701
1702 smooth_max[x + 1][y + 1] =
1703 MAX (self->tex [cell->tile [0]].smoothlevel,
1704 MAX (self->tex [cell->tile [1]].smoothlevel,
1705 self->tex [cell->tile [2]].smoothlevel));
1706 }
1707 }
1708
1476 for (z = 0; z < 3; z++) 1709 for (z = 0; z <= 2; z++)
1710 {
1711 memset (smooth_level, 0, sizeof (smooth_level));
1712
1477 for (y = 0; y < sh; y++) 1713 for (y = 0; y < sh; y++)
1478 if (0 <= y + my && y + my < self->rows) 1714 if (0 <= y + my && y + my < self->rows)
1479 { 1715 {
1480 maprow *row = self->row + (y + my); 1716 maprow *row = self->row + (y + my);
1481 1717
1482 for (x = 0; x < sw; x++) 1718 for (x = 0; x < sw; x++)
1483 if (row->c0 <= x + mx && x + mx < row->c1) 1719 if (row->c0 <= x + mx && x + mx < row->c1)
1484 { 1720 {
1485 mapcell *cell = row->col + (x + mx - row->c0); 1721 mapcell *cell = row->col + (x + mx - row->c0);
1486
1487 face = cell->face [z]; 1722 tileid tile = cell->tile [z];
1723
1724 if (tile)
1725 {
1726 maptex tex = self->tex [tile];
1727 int px = (x + 1) * T - tex.w;
1728 int py = (y + 1) * T - tex.h;
1488 1729
1489 if (face && face < self->texs) 1730 // suppressing texture state switches here
1731 // is only moderately effective, but worth the extra effort
1732 if (last_name != tex.name)
1733 {
1734 if (!tex.name)
1735 tex = self->tex [2]; /* missing, replace by noface */
1736
1737 glEnd ();
1738 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1739 glBegin (GL_QUADS);
1740 }
1741
1742 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1743 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
1744 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1745 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1746
1747 if (cell->flags && z == 2)
1748 {
1749 if (cell->flags & 1)
1750 {
1751 maptex tex = self->tex [1];
1752 int px = x * T + T * 2 / 32;
1753 int py = y * T - T * 6 / 32;
1754
1755 glEnd ();
1756 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1757 glBegin (GL_QUADS);
1758
1759 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1760 glTexCoord2f (0 , tex.t); glVertex2f (px , py + T);
1761 glTexCoord2f (tex.s, tex.t); glVertex2f (px + T, py + T);
1762 glTexCoord2f (tex.s, 0 ); glVertex2f (px + T, py );
1763 }
1764 }
1765
1766 // update smooth hash
1767 if (tex.smoothtile)
1768 {
1769 skey.tile = tex.smoothtile;
1770 skey.level = tex.smoothlevel;
1771
1772 smooth_level [tex.smoothlevel >> 5] |= ((uint32_t)1) << (tex.smoothlevel & 31);
1773
1774 // add bits to current tile and all neighbours. skey.x|y is
1775 // shifted +1|+1 so we always stay positive.
1776
1777 // bits is ___n cccc CCCC bbbb
1778 // n do not draw borders&corners
1779 // c draw these corners, but...
1780 // C ... not these
1781 // b draw these borders
1782
1783 // borders: 1 ┃· 2 ━━ 4 ·┃ 8 ··
1784 // ┃· ·· ·┃ ━━
1785
1786 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
1787 // ·· ·· ·┏ ┓·
1788
1789 // full tile
1790 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000);
1791
1792 // borders
1793 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091);
1794 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032);
1795 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064);
1796 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8);
1797
1798 // corners
1799 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100);
1800 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200);
1801 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400);
1802 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800);
1803 }
1804 }
1805 }
1806 }
1807
1808 // go through all smoothlevels, lowest to highest, then draw.
1809 // this is basically counting sort
1810 {
1811 int w, b;
1812
1813 for (w = 0; w < 256 / 32; ++w)
1814 {
1815 uint32_t smask = smooth_level [w];
1816 if (smask)
1817 for (b = 0; b < 32; ++b)
1818 if (smask & (((uint32_t)1) << b))
1490 { 1819 {
1491 maptex tex = self->tex [face]; 1820 int level = (w << 5) | b;
1492 int px = (x + 1) * 32 - tex.w; 1821 HE *he;
1493 int py = (y + 1) * 32 - tex.h;
1494 1822
1495 if (last_name != tex.name) 1823 hv_iterinit (smooth);
1824 while ((he = hv_iternext (smooth)))
1496 { 1825 {
1826 smooth_key *skey = (smooth_key *)HeKEY (he);
1827 IV bits = SvIVX (HeVAL (he));
1828
1829 if (!(bits & 0x1000)
1830 && skey->level == level
1831 && level > smooth_max [skey->x][skey->y])
1832 {
1833 maptex tex = self->tex [skey->tile];
1834 int px = (((int)skey->x) - 1) * T;
1835 int py = (((int)skey->y) - 1) * T;
1836 int border = bits & 15;
1837 int corner = (bits >> 8) & ~(bits >> 4) & 15;
1838 float dx = tex.s * .0625f; // 16 images/row
1839 float dy = tex.t * .5f ; // 2 images/column
1840
1841 // this time naively avoiding texture state changes
1842 // save gobs of state changes.
1843 if (last_name != tex.name)
1844 {
1845 if (!tex.name)
1846 continue; // smoothing not yet available
1847
1497 glEnd (); 1848 glEnd ();
1498 glBindTexture (GL_TEXTURE_2D, last_name = tex.name); 1849 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1499 glBegin (GL_QUADS); 1850 glBegin (GL_QUADS);
1851 }
1852
1853 if (border)
1854 {
1855 float ox = border * dx;
1856
1857 glTexCoord2f (ox , 0.f ); glVertex2f (px , py );
1858 glTexCoord2f (ox , dy ); glVertex2f (px , py + T);
1859 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py + T);
1860 glTexCoord2f (ox + dx, 0.f ); glVertex2f (px + T, py );
1861 }
1862
1863 if (corner)
1864 {
1865 float ox = corner * dx;
1866
1867 glTexCoord2f (ox , dy ); glVertex2f (px , py );
1868 glTexCoord2f (ox , dy * 2.f); glVertex2f (px , py + T);
1869 glTexCoord2f (ox + dx, dy * 2.f); glVertex2f (px + T, py + T);
1870 glTexCoord2f (ox + dx, dy ); glVertex2f (px + T, py );
1871 }
1500 } 1872 }
1501
1502 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1503 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
1504 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1505 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1506 }
1507
1508 if (cell->flags && z == 2)
1509 {
1510 if (cell->flags & 1)
1511 {
1512 maptex tex = self->tex [1];
1513 int px = (x + 1) * 32 - tex.w + 2;
1514 int py = (y + 1) * 32 - tex.h - 6;
1515
1516 glEnd ();
1517 glBindTexture (GL_TEXTURE_2D, last_name = tex.name);
1518 glBegin (GL_QUADS);
1519
1520 glTexCoord2f (0 , 0 ); glVertex2f (px , py );
1521 glTexCoord2f (0 , tex.t); glVertex2f (px , py + tex.h);
1522 glTexCoord2f (tex.s, tex.t); glVertex2f (px + tex.w, py + tex.h);
1523 glTexCoord2f (tex.s, 0 ); glVertex2f (px + tex.w, py );
1524 } 1873 }
1525 } 1874 }
1526 }
1527 } 1875 }
1876 }
1877
1878 hv_clear (smooth);
1879 }
1528 1880
1529 glEnd (); 1881 glEnd ();
1530 1882
1531 glDisable (GL_TEXTURE_2D); 1883 glDisable (GL_TEXTURE_2D);
1532 glDisable (GL_BLEND); 1884 glDisable (GL_BLEND);
1540 for (x = 0; x < sw; x++) 1892 for (x = 0; x < sw; x++)
1541 if (row->c0 <= x + mx && x + mx < row->c1) 1893 if (row->c0 <= x + mx && x + mx < row->c1)
1542 { 1894 {
1543 mapcell *cell = row->col + (x + mx - row->c0); 1895 mapcell *cell = row->col + (x + mx - row->c0);
1544 1896
1545 int px = x * 32; 1897 int px = x * T;
1546 int py = y * 32; 1898 int py = y * T;
1547 1899
1548 if (cell->stat_hp) 1900 if (cell->stat_hp)
1549 { 1901 {
1550 int width = cell->stat_width * 32; 1902 int width = cell->stat_width * T;
1551 int thick = sh / 28 + 1 + cell->stat_width; 1903 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width;
1552 1904
1553 glColor3ub (0, 0, 0); 1905 glColor3ub (0, 0, 0);
1554 glRectf (px + 1, py - thick - 2, 1906 glRectf (px + 1, py - thick - 2,
1555 px + width - 1, py); 1907 px + width - 1, py);
1556 1908
1622 glDisable (GL_BLEND); 1974 glDisable (GL_BLEND);
1623 glDisable (GL_TEXTURE_2D); 1975 glDisable (GL_TEXTURE_2D);
1624} 1976}
1625 1977
1626void 1978void
1627fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh) 1979fow_texture (CFPlus::Map self, int mx, int my, int sw, int sh, int smoothing, const char *matrix)
1628 PPCODE: 1980 PPCODE:
1629{ 1981{
1630 int x, y; 1982 int x, y;
1631 int sw4 = (sw + 3) & ~3; 1983 int sw4 = (sw + 3) & ~3;
1632 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh)); 1984 SV *darkness_sv = sv_2mortal (newSV (sw4 * sh));
1652 darkness[y * sw4 + x] = cell->darkness 2004 darkness[y * sw4 + x] = cell->darkness
1653 ? 255 - (cell->darkness - 1) 2005 ? 255 - (cell->darkness - 1)
1654 : 255 - FOW_DARKNESS; 2006 : 255 - FOW_DARKNESS;
1655 } 2007 }
1656 } 2008 }
2009
2010 if (smoothing)
2011 {
2012 SV *darkness2_sv = sv_2mortal (newSV (sw4 * sh));
2013 uint8_t *darkness2 = (uint8_t *)SvPVX (darkness2_sv);
2014
2015 SvPOK_only (darkness2_sv);
2016 SvCUR_set (darkness2_sv, sw4 * sh);
2017
2018 for (y = 0; y < sh; ++y)
2019 for (x = 0; x < sw4; ++x)
2020 {
2021 float *f = (float *)matrix;
2022 int dx, dy;
2023 float sum = 0.f;
2024
2025 for (dy = -1; dy <= 1; ++dy)
2026 for (dx = -1; dx <= 1; ++dx)
2027 {
2028 unsigned int x2 = x + dx;
2029 unsigned int y2 = y + dy;
2030
2031 sum += (x2 < sw && y2 < sh ? darkness [y2 * sw4 + x2] : 255) * *f++;
2032 }
2033
2034 darkness2 [y * sw4 + x] = sum > 255. ? 255. : sum;
2035 }
2036
2037 darkness_sv = darkness2_sv;
2038 }
1657 2039
1658 EXTEND (SP, 3); 2040 EXTEND (SP, 3);
1659 PUSHs (sv_2mortal (newSViv (sw4))); 2041 PUSHs (sv_2mortal (newSViv (sw4)));
1660 PUSHs (sv_2mortal (newSViv (sh))); 2042 PUSHs (sv_2mortal (newSViv (sh)));
1661 PUSHs (darkness_sv); 2043 PUSHs (darkness_sv);
1695 if (row && row->c0 <= x && x < row->c1) 2077 if (row && row->c0 <= x && x < row->c1)
1696 { 2078 {
1697 mapcell *cell = row->col + (x - row->c0); 2079 mapcell *cell = row->col + (x - row->c0);
1698 uint8_t flags = 0; 2080 uint8_t flags = 0;
1699 2081
1700 if (cell->face [0]) flags |= 1; 2082 if (cell->tile [0]) flags |= 1;
1701 if (cell->face [1]) flags |= 2; 2083 if (cell->tile [1]) flags |= 2;
1702 if (cell->face [2]) flags |= 4; 2084 if (cell->tile [2]) flags |= 4;
1703 2085
1704 *data++ = flags; 2086 *data++ = flags;
1705 2087
1706 if (flags & 1) 2088 if (flags & 1)
1707 { 2089 {
2090 tileid tile = cell->tile [0];
1708 *data++ = cell->face [0] >> 8; 2091 *data++ = tile >> 8;
1709 *data++ = cell->face [0]; 2092 *data++ = tile;
1710 } 2093 }
1711 2094
1712 if (flags & 2) 2095 if (flags & 2)
1713 { 2096 {
2097 tileid tile = cell->tile [1];
1714 *data++ = cell->face [1] >> 8; 2098 *data++ = tile >> 8;
1715 *data++ = cell->face [1]; 2099 *data++ = tile;
1716 } 2100 }
1717 2101
1718 if (flags & 4) 2102 if (flags & 4)
1719 { 2103 {
2104 tileid tile = cell->tile [2];
1720 *data++ = cell->face [2] >> 8; 2105 *data++ = tile >> 8;
1721 *data++ = cell->face [2]; 2106 *data++ = tile;
1722 } 2107 }
1723 } 2108 }
1724 else 2109 else
1725 *data++ = 0; 2110 *data++ = 0;
1726 } 2111 }
1766 { 2151 {
1767 uint8_t flags = *data++; 2152 uint8_t flags = *data++;
1768 2153
1769 if (flags) 2154 if (flags)
1770 { 2155 {
1771 mapface face[3] = { 0, 0, 0 };
1772
1773 mapcell *cell = row_get_cell (row, x); 2156 mapcell *cell = row_get_cell (row, x);
2157 tileid tile[3] = { 0, 0, 0 };
1774 2158
1775 if (flags & 1) { face[0] = *data++ << 8; face[0] |= *data++; } 2159 if (flags & 1) { tile[0] = *data++ << 8; tile[0] |= *data++; }
1776 if (flags & 2) { face[1] = *data++ << 8; face[1] |= *data++; } 2160 if (flags & 2) { tile[1] = *data++ << 8; tile[1] |= *data++; }
1777 if (flags & 4) { face[2] = *data++ << 8; face[2] |= *data++; } 2161 if (flags & 4) { tile[2] = *data++ << 8; tile[2] |= *data++; }
1778 2162
1779 if (cell->darkness == 0) 2163 if (cell->darkness == 0)
1780 { 2164 {
1781 cell->darkness = 0; 2165 cell->darkness = 0;
1782 2166
1783 for (z = 0; z <= 2; z++) 2167 for (z = 0; z <= 2; z++)
1784 { 2168 {
1785 cell->face[z] = face[z]; 2169 tileid t = tile [z];
1786 2170
1787 if (face[z] && (face[z] >= self->texs || !self->tex[face [z]].name)) 2171 if (t >= self->texs || (t && !self->tex [t].name))
2172 {
1788 XPUSHs (sv_2mortal (newSViv (face[z]))); 2173 XPUSHs (sv_2mortal (newSViv (t)));
2174 need_texid (self, t);
2175 }
2176
2177 cell->tile [z] = t;
1789 } 2178 }
1790 } 2179 }
1791 } 2180 }
1792 } 2181 }
1793 } 2182 }
1828 CODE: 2217 CODE:
1829 RETVAL = Mix_VolumeMusic (volume); 2218 RETVAL = Mix_VolumeMusic (volume);
1830 OUTPUT: 2219 OUTPUT:
1831 RETVAL 2220 RETVAL
1832 2221
2222int
2223fade_out (int ms)
2224 CODE:
2225 RETVAL = Mix_FadeOutMusic (ms);
2226 OUTPUT:
2227 RETVAL
2228
1833CFPlus::MixMusic 2229CFPlus::MixMusic
1834new_from_file (SV *class, char *path) 2230new_from_file (SV *class, char *path)
1835 CODE: 2231 CODE:
1836 RETVAL = Mix_LoadMUS (path); 2232 RETVAL = Mix_LoadMUS (path);
1837 OUTPUT: 2233 OUTPUT:
1844 2240
1845int 2241int
1846play (CFPlus::MixMusic self, int loops = -1) 2242play (CFPlus::MixMusic self, int loops = -1)
1847 CODE: 2243 CODE:
1848 RETVAL = Mix_PlayMusic (self, loops); 2244 RETVAL = Mix_PlayMusic (self, loops);
2245 OUTPUT:
2246 RETVAL
2247
2248int
2249fade_in_pos (CFPlus::MixMusic self, int loops, int ms, double position)
2250 CODE:
2251 RETVAL = Mix_FadeInMusicPos (self, loops, ms, position);
1849 OUTPUT: 2252 OUTPUT:
1850 RETVAL 2253 RETVAL
1851 2254
1852MODULE = CFPlus PACKAGE = CFPlus::OpenGL 2255MODULE = CFPlus PACKAGE = CFPlus::OpenGL
1853 2256
1857 static const struct { 2260 static const struct {
1858 const char *name; 2261 const char *name;
1859 IV iv; 2262 IV iv;
1860 } *civ, const_iv[] = { 2263 } *civ, const_iv[] = {
1861# define const_iv(name) { # name, (IV)name } 2264# define const_iv(name) { # name, (IV)name }
2265 const_iv (GL_VENDOR),
2266 const_iv (GL_VERSION),
2267 const_iv (GL_EXTENSIONS),
1862 const_iv (GL_COLOR_MATERIAL), 2268 const_iv (GL_COLOR_MATERIAL),
1863 const_iv (GL_SMOOTH), 2269 const_iv (GL_SMOOTH),
1864 const_iv (GL_FLAT), 2270 const_iv (GL_FLAT),
1865 const_iv (GL_DITHER), 2271 const_iv (GL_DITHER),
1866 const_iv (GL_BLEND), 2272 const_iv (GL_BLEND),
1893 const_iv (GL_LUMINANCE), 2299 const_iv (GL_LUMINANCE),
1894 const_iv (GL_LUMINANCE_ALPHA), 2300 const_iv (GL_LUMINANCE_ALPHA),
1895 const_iv (GL_FLOAT), 2301 const_iv (GL_FLOAT),
1896 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV), 2302 const_iv (GL_UNSIGNED_INT_8_8_8_8_REV),
1897 const_iv (GL_COMPILE), 2303 const_iv (GL_COMPILE),
2304 const_iv (GL_PROXY_TEXTURE_1D),
2305 const_iv (GL_PROXY_TEXTURE_2D),
1898 const_iv (GL_TEXTURE_1D), 2306 const_iv (GL_TEXTURE_1D),
1899 const_iv (GL_TEXTURE_2D), 2307 const_iv (GL_TEXTURE_2D),
1900 const_iv (GL_TEXTURE_ENV), 2308 const_iv (GL_TEXTURE_ENV),
1901 const_iv (GL_TEXTURE_MAG_FILTER), 2309 const_iv (GL_TEXTURE_MAG_FILTER),
1902 const_iv (GL_TEXTURE_MIN_FILTER), 2310 const_iv (GL_TEXTURE_MIN_FILTER),
1942# undef const_iv 2350# undef const_iv
1943 }; 2351 };
1944 2352
1945 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 2353 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1946 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 2354 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
2355
2356 texture_av = newAV ();
2357 AvREAL_off (texture_av);
1947} 2358}
1948 2359
1949char * 2360char *
1950gl_vendor () 2361gl_vendor ()
1951 CODE: 2362 CODE:
1962 2373
1963char * 2374char *
1964gl_extensions () 2375gl_extensions ()
1965 CODE: 2376 CODE:
1966 RETVAL = (char *)glGetString (GL_EXTENSIONS); 2377 RETVAL = (char *)glGetString (GL_EXTENSIONS);
2378 OUTPUT:
2379 RETVAL
2380
2381const char *glGetString (GLenum pname)
2382
2383GLint glGetInteger (GLenum pname)
2384 CODE:
2385 glGetIntegerv (pname, &RETVAL);
2386 OUTPUT:
2387 RETVAL
2388
2389GLdouble glGetDouble (GLenum pname)
2390 CODE:
2391 glGetDoublev (pname, &RETVAL);
1967 OUTPUT: 2392 OUTPUT:
1968 RETVAL 2393 RETVAL
1969 2394
1970int glGetError () 2395int glGetError ()
1971 2396
2096 2521
2097void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border) 2522void glCopyTexImage2D (int target, int level, int internalformat, int x, int y, int width, int height, int border)
2098 2523
2099void glDrawPixels (int width, int height, int format, int type, char *pixels) 2524void glDrawPixels (int width, int height, int format, int type, char *pixels)
2100 2525
2526void glPixelZoom (float x, float y)
2527
2101void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR) 2528void glCopyPixels (int x, int y, int width, int height, int type = GL_COLOR)
2102 2529
2103int glGenTexture () 2530int glGenTexture ()
2104 CODE: 2531 CODE:
2105{ 2532 RETVAL = gen_texture ();
2106 GLuint name;
2107 glGenTextures (1, &name);
2108 RETVAL = name;
2109}
2110 OUTPUT: 2533 OUTPUT:
2111 RETVAL 2534 RETVAL
2112 2535
2113void glDeleteTexture (int name) 2536void glDeleteTexture (int name)
2114 CODE: 2537 CODE:
2115{
2116 GLuint name_ = name;
2117 glDeleteTextures (1, &name_); 2538 del_texture (name);
2118} 2539
2119
2120int glGenList () 2540int glGenList ()
2121 CODE: 2541 CODE:
2122 RETVAL = glGenLists (1); 2542 RETVAL = glGenLists (1);
2123 OUTPUT: 2543 OUTPUT:
2124 RETVAL 2544 RETVAL

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines