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.70 by root, Sun Apr 30 09:21:47 2006 UTC vs.
Revision 1.212 by root, Sun Jul 29 03:58:26 2007 UTC

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines