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

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines