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.302 by root, Tue Apr 20 10:53:11 2010 UTC vs.
Revision 1.324 by root, Sun Nov 18 01:58:53 2018 UTC

… …
15 15
16#include "EXTERN.h" 16#include "EXTERN.h"
17#include "perl.h" 17#include "perl.h"
18#include "XSUB.h" 18#include "XSUB.h"
19 19
20#include "flat_hash_map.hpp"
21
20#ifdef _WIN32 22#ifdef _WIN32
21# undef pipe 23# undef pipe
22// microsoft vs. C 24// microsoft vs. C
23# define sqrtf(x) sqrt(x) 25# define sqrtf(x) sqrt(x)
24# define atan2f(x,y) atan2(x,y) 26# define atan2f(x,y) atan2(x,y)
25# define M_PI 3.14159265f 27# define M_PI 3.14159265f
26#endif 28#endif
27 29
28#include <assert.h> 30#include <cassert>
29#include <math.h> 31#include <cmath>
30#include <string.h> 32#include <cstring>
31#include <stdio.h> 33#include <cstdio>
32#include <stdlib.h> 34#include <cstdlib>
35
36#include <utility>
37#include <bitset>
33 38
34#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW 39#define USE_RWOPS 1 // for SDL_mixer:LoadMUS_RW
35 40
36#include <SDL.h> 41#include <SDL.h>
37#include <SDL_thread.h> 42#include <SDL_thread.h>
… …
48#endif 53#endif
49 54
50#define PANGO_ENABLE_BACKEND 55#define PANGO_ENABLE_BACKEND
51#define G_DISABLE_CAST_CHECKS 56#define G_DISABLE_CAST_CHECKS
52 57
53#include <glib/gmacros.h> 58#include <glib.h>
54 59
55#include <pango/pango.h> 60#include <pango/pango.h>
56 61
57#ifndef PANGO_VERSION_CHECK 62#ifndef PANGO_VERSION_CHECK
58# define PANGO_VERSION_CHECK(a,b,c) 0 63# define PANGO_VERSION_CHECK(a,b,c) 0
… …
100#define KMOD_LRAM 0x10000 // our extension 105#define KMOD_LRAM 0x10000 // our extension
101 106
102#define TEXID_SPEECH 1 107#define TEXID_SPEECH 1
103#define TEXID_NOFACE 2 108#define TEXID_NOFACE 2
104 109
110static char *
111fast_sv_grow (SV *sv, STRLEN need)
112{
113 STRLEN len = SvLEN (sv);
114 STRLEN want = SvCUR (sv) + need;
115
116 if (expect_false (len < want))
117 {
118 do
119 len *= 2;
120 while (len < want);
121
122 sv_grow (sv, len);
123 }
124
125 SvCUR_set (sv, want);
126 return SvEND (sv) - need;
127}
128
105static AV *texture_av; 129static AV *texture_av;
106 130
107static struct 131static struct
108{ 132{
109#define GL_FUNC(ptr,name) ptr name; 133#define GL_FUNC(ptr,name) ptr name;
… …
165{ 189{
166 GSList *attrs = run->item->analysis.extra_attrs; 190 GSList *attrs = run->item->analysis.extra_attrs;
167 191
168 while (attrs) 192 while (attrs)
169 { 193 {
170 PangoAttribute *attr = attrs->data; 194 PangoAttribute *attr = (PangoAttribute *)attrs->data;
171 195
172 if (attr->klass->type == PANGO_ATTR_SHAPE) 196 if (attr->klass->type == PANGO_ATTR_SHAPE)
173 return 1; 197 return 1;
174 198
175 attrs = attrs->next; 199 attrs = attrs->next;
176 } 200 }
177 201
178 return 0; 202 return 0;
179} 203}
180 204
181typedef struct cf_layout { 205struct cf_layout {
182 PangoLayout *pl; 206 PangoLayout *pl;
183 float r, g, b, a; // default color for rgba mode 207 float r, g, b, a; // default color for rgba mode
184 int base_height; 208 int base_height;
185 DC__Font font; 209 DC__Font font;
186 rc_t *rc; 210 rc_t *rc;
187} *DC__Layout; 211};
212
213typedef cf_layout *DC__Layout;
188 214
189static DC__Font default_font; 215static DC__Font default_font;
190static PangoContext *opengl_context; 216static PangoContext *opengl_context;
191static PangoFontMap *opengl_fontmap; 217static PangoFontMap *opengl_fontmap;
192 218
193static void 219static void
194substitute_func (FcPattern *pattern, gpointer data) 220substitute_func (FcPattern *pattern, gpointer data)
195{ 221{
196 FcPatternAddBool (pattern, FC_HINTING, 1); 222 FcPatternAddBool (pattern, FC_HINTING, 1);
197#ifdef FC_HINT_STYLE 223#ifdef FC_HINT_STYLE
198 FcPatternAddBool (pattern, FC_HINT_STYLE, FC_HINT_FULL); 224 FcPatternAddInteger (pattern, FC_HINT_STYLE, FC_HINT_FULL);
199#endif 225#endif
200 FcPatternAddBool (pattern, FC_AUTOHINT, 0); 226 FcPatternAddBool (pattern, FC_AUTOHINT, 0);
201} 227}
202 228
203static void 229static void
… …
233} 259}
234 260
235typedef uint16_t tileid; 261typedef uint16_t tileid;
236typedef uint16_t faceid; 262typedef uint16_t faceid;
237 263
238typedef struct { 264struct maptex
265{
239 GLuint name; 266 GLuint name;
240 int w, h; 267 int w, h;
241 float s, t; 268 float s, t;
242 uint8_t r, g, b, a; 269 uint8_t r, g, b, a;
243 tileid smoothtile; 270 tileid smoothtile;
244 uint8_t smoothlevel; 271 uint8_t smoothlevel;
245 uint8_t unused; /* set to zero on use */ 272 uint8_t unused; /* set to zero on use */
246} maptex; 273};
247 274
248typedef struct { 275struct mapcell
276{
249 uint32_t player; 277 uint32_t player;
250 tileid tile[3]; 278 tileid tile[3];
251 uint16_t darkness; 279 uint16_t darkness;
252 uint8_t stat_width, stat_hp, flags, smoothmax; 280 uint8_t stat_width, stat_hp, flags, smoothmax;
253} mapcell; 281};
254 282
255typedef struct { 283struct maprow
284{
256 int32_t c0, c1; 285 int32_t c0, c1;
257 mapcell *col; 286 mapcell *col;
258} maprow; 287};
259 288
260typedef struct map { 289struct mapgrid {
261 int x, y, w, h; 290 int x, y, w, h;
262 int ox, oy; /* offset to virtual global coordinate system */ 291 int ox, oy; /* offset to virtual global coordinate system */
263 int faces; tileid *face2tile; // [faceid] 292 int faces; tileid *face2tile; // [faceid]
264 int texs; maptex *tex; // [tileid] 293 int texs; maptex *tex; // [tileid]
265 294
266 int32_t rows; 295 int32_t rows;
267 maprow *row; 296 maprow *row;
268} *DC__Map; 297};
298
299typedef mapgrid *DC__Map;
269 300
270static char * 301static char *
271prepend (char *ptr, int sze, int inc) 302prepend (char *ptr, int sze, int inc)
272{ 303{
273 char *p; 304 char *p;
… …
291 322
292#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type)) 323#define Append(type,ptr,sze,inc) (ptr) = (type *)append ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
293#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type)) 324#define Prepend(type,ptr,sze,inc) (ptr) = (type *)prepend ((char *)ptr, (sze) * sizeof (type), (inc) * sizeof (type))
294 325
295static void 326static void
296need_facenum (struct map *self, faceid face) 327need_facenum (struct mapgrid *self, faceid face)
297{ 328{
298 while (self->faces <= face) 329 while (self->faces <= face)
299 { 330 {
300 Append (tileid, self->face2tile, self->faces, self->faces); 331 Append (tileid, self->face2tile, self->faces, self->faces);
301 self->faces *= 2; 332 self->faces *= 2;
302 } 333 }
303} 334}
304 335
305static void 336static void
306need_texid (struct map *self, int texid) 337need_texid (struct mapgrid *self, int texid)
307{ 338{
308 while (self->texs <= texid) 339 while (self->texs <= texid)
309 { 340 {
310 Append (maptex, self->tex, self->texs, self->texs); 341 Append (maptex, self->tex, self->texs, self->texs);
311 self->texs *= 2; 342 self->texs *= 2;
312 } 343 }
313} 344}
314 345
315static maprow * 346static maprow *
316map_get_row (DC__Map self, int y) 347map_get_row (mapgrid *self, int y)
317{ 348{
318 if (0 > y) 349 if (0 > y)
319 { 350 {
320 int extend = - y + MAP_EXTEND_Y; 351 int extend = - y + MAP_EXTEND_Y;
321 Prepend (maprow, self->row, self->rows, extend); 352 Prepend (maprow, self->row, self->rows, extend);
… …
359 390
360 return row->col + (x - row->c0); 391 return row->col + (x - row->c0);
361} 392}
362 393
363static mapcell * 394static mapcell *
364map_get_cell (DC__Map self, int x, int y) 395map_get_cell (mapgrid *self, int x, int y)
365{ 396{
366 return row_get_cell (map_get_row (self, y), x); 397 return row_get_cell (map_get_row (self, y), x);
367} 398}
368 399
369static void 400static void
370map_clear (DC__Map self) 401map_clear (mapgrid *self)
371{ 402{
372 int r; 403 int r;
373 404
374 for (r = 0; r < self->rows; r++) 405 for (r = 0; r < self->rows; r++)
375 Safefree (self->row[r].col); 406 Safefree (self->row[r].col);
… …
393 (cell)->flags = 0; \ 424 (cell)->flags = 0; \
394 (cell)->player = 0; \ 425 (cell)->player = 0; \
395 } while (0) 426 } while (0)
396 427
397static void 428static void
398map_blank (DC__Map self, int x0, int y0, int w, int h) 429map_blank (mapgrid *self, int x0, int y0, int w, int h)
399{ 430{
400 int x, y; 431 int x, y;
401 maprow *row; 432 maprow *row;
402 mapcell *cell; 433 mapcell *cell;
403 434
… …
420 CELL_CLEAR (cell); 451 CELL_CLEAR (cell);
421 } 452 }
422 } 453 }
423} 454}
424 455
425typedef struct { 456struct smooth_key
457{
426 tileid tile; 458 tileid tile;
427 uint8_t x, y, level; 459 uint8_t x, y, level;
428} smooth_key; 460
461 bool operator == (const smooth_key &o) const
462 {
463 return tile == o.tile && x == o.x && y == o.y && level == o.level;
464 }
465};
466
467typedef ska::flat_hash_map<smooth_key, IV> smooth_hash;
468
469namespace std {
470 template <>
471 struct hash<smooth_key>
472 {
473 size_t operator () (const smooth_key &v) const
474 {
475 return v.tile + (v.x << 8) + (v.y << 16) + (v.level << 24);
476 }
477 };
478}
429 479
430static void 480static void
431smooth_or_bits (HV *hv, smooth_key *key, IV bits) 481smooth_or_bits (smooth_hash &h, smooth_key &key, IV bits)
432{ 482{
433 SV **sv = hv_fetch (hv, (char *)key, sizeof (*key), 1); 483 auto &&it = h.find (key);
434 484
435 if (SvIOK (*sv)) 485 if (it == h.end ())
436 SvIV_set (*sv, SvIVX (*sv) | bits); 486 h.insert (std::make_pair (key, bits));
437 else 487 else
438 sv_setiv (*sv, bits); 488 it->second |= bits;
439} 489}
440 490
441static void 491static void
442music_finished (void) 492music_finished (void)
443{ 493{
… …
460 ev.code = 1; 510 ev.code = 1;
461 ev.data1 = (void *)(long)channel; 511 ev.data1 = (void *)(long)channel;
462 ev.data2 = 0; 512 ev.data2 = 0;
463 513
464 SDL_PushEvent ((SDL_Event *)&ev); 514 SDL_PushEvent ((SDL_Event *)&ev);
515}
516
517// approximately divide by 255
518static unsigned int
519div255 (unsigned int n)
520{
521 return (n + (n >> 8)) >> 8;
465} 522}
466 523
467static unsigned int 524static unsigned int
468minpot (unsigned int n) 525minpot (unsigned int n)
469{ 526{
… …
552 609
553 return mod; 610 return mod;
554} 611}
555 612
556static void 613static void
557deliantra_main () 614deliantra_main (SV *real_main)
558{ 615{
559 char *argv[] = { 0 }; 616 dSP;
560 call_argv ("::main", G_DISCARD | G_VOID, argv); 617
618 PUSHMARK (SP);
619 call_sv (real_main, G_DISCARD | G_VOID);
561} 620}
562 621
563#ifdef __MACOSX__ 622#ifdef __MACOSX__
623 static SV *real_main;
624
564 /* to due surprising braindamage on the side of SDL design, we 625 /* to due surprising braindamage on the side of SDL design, we
565 * do some mind-boggling hack here: SDL requires a custom main() 626 * do some mind-boggling hack here: SDL requires a custom main()
566 * on OS X, so... we provide one and call the original main(), which, 627 * on OS X, so... we provide one and call the original main(), which,
567 * due to share dlibrary magic, calls -lSDLmain's main, not perl's main, 628 * due to shared library magic, calls -lSDLmain's main, not perl's main,
568 * and which calls our main (== SDL_main) back. 629 * and which calls our main (== SDL_main) back.
569 */ 630 */
570 extern C_LINKAGE int 631 extern C_LINKAGE int
571 main (int argc, char *argv[]) 632 main (int argc, char *argv[])
572 { 633 {
573 deliantra_main (); 634 deliantra_main (real_main);
574 } 635 }
575 636
576 #undef main 637 #undef main
577 638
578 extern C_LINKAGE int main (int argc, char *argv[]); 639 extern C_LINKAGE int main (int argc, char *argv[]);
579 640
580 static void 641 static void
581 SDL_braino (void) 642 SDL_main_hack (SV *real_main_)
582 { 643 {
644 real_main = real_main_;
645
583 char *argv[] = { "deliantra client", 0 }; 646 char *argv[] = { "deliantra client", 0 };
584 (main) (1, argv); 647 (main) (1, argv);
585 } 648 }
586#else 649#else
587 static void 650 static void
588 SDL_braino (void) 651 SDL_main_hack (SV *real_main)
589 { 652 {
590 deliantra_main (); 653 deliantra_main (real_main);
591 } 654 }
592#endif 655#endif
593 656
594MODULE = Deliantra::Client PACKAGE = DC 657MODULE = Deliantra::Client PACKAGE = DC
595 658
… …
796 859
797 const_iv (FOW_DARKNESS) 860 const_iv (FOW_DARKNESS)
798# undef const_iv 861# undef const_iv
799 }; 862 };
800 863
801 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 864 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
802 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 865 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
803 866
804 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK); 867 assert (SDLK_MODIFIER_MIN == SDLK_NUMLOCK);
805 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE); 868 assert (SDLK_MODIFIER_MAX == SDLK_COMPOSE);
806} 869}
807 870
… …
846#endif 909#endif
847} 910}
848 911
849char *SDL_GetError () 912char *SDL_GetError ()
850 913
851void SDL_braino () 914void SDL_main_hack (SV *real_main)
915 PROTOTYPE: &
852 916
853int SDL_Init (U32 flags) 917int SDL_Init (U32 flags)
854 918
855int SDL_InitSubSystem (U32 flags) 919int SDL_InitSubSystem (U32 flags)
856 920
857void SDL_QuitSubSystem (U32 flags) 921void SDL_QuitSubSystem (U32 flags)
858 922
859void SDL_Quit () 923void SDL_Quit ()
860 924
861int SDL_GL_SetAttribute (int attr, int value) 925int SDL_GL_SetAttribute (int attr, int value)
926 C_ARGS: (SDL_GLattr)attr, value
862 927
863int SDL_GL_GetAttribute (int attr) 928int SDL_GL_GetAttribute (int attr)
864 CODE: 929 CODE:
865 if (SDL_GL_GetAttribute (attr, &RETVAL)) 930 if (SDL_GL_GetAttribute ((SDL_GLattr)attr, &RETVAL))
866 XSRETURN_UNDEF; 931 XSRETURN_UNDEF;
867 OUTPUT: 932 OUTPUT:
868 RETVAL 933 RETVAL
869 934
870void 935void
… …
925 ); 990 );
926 991
927 if (RETVAL) 992 if (RETVAL)
928 { 993 {
929 av_clear (texture_av); 994 av_clear (texture_av);
930
931 SDL_WM_SetCaption ("Deliantra MORPG Client " VERSION, "Deliantra");
932#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name); 995#define GL_FUNC(ptr,name) gl.name = (ptr)SDL_GL_GetProcAddress ("gl" # name);
933#include "glfunc.h" 996#include "glfunc.h"
934#undef GL_FUNC 997#undef GL_FUNC
935
936 if (!gl.ActiveTexture ) gl.ActiveTexture = gl.ActiveTextureARB; 998 if (!gl.ActiveTexture ) gl.ActiveTexture = gl.ActiveTextureARB;
937 if (!gl.MultiTexCoord2f) gl.MultiTexCoord2f = gl.MultiTexCoord2fARB; 999 if (!gl.MultiTexCoord2f) gl.MultiTexCoord2f = gl.MultiTexCoord2fARB;
938 } 1000 }
939} 1001}
940 OUTPUT: 1002 OUTPUT:
941 RETVAL 1003 RETVAL
942 1004
943void 1005void
1006SDL_WM_SetCaption (const char *title, const char *icon)
1007
1008void
944SDL_GL_SwapBuffers () 1009SDL_GL_SwapBuffers ()
945 1010
946char * 1011char *
947SDL_GetKeyName (int sym) 1012SDL_GetKeyName (int sym)
1013 C_ARGS: (SDLKey)sym
948 1014
949int 1015int
950SDL_GetAppState () 1016SDL_GetAppState ()
951 1017
952int 1018int
953SDL_GetModState () 1019SDL_GetModState ()
954 1020
1021int
1022SDL_WaitEvent ()
1023 C_ARGS: 0
1024
955void 1025void
1026SDL_PumpEvents ()
1027
1028void
956poll_events () 1029peep_events ()
957 PPCODE: 1030 PPCODE:
958{ 1031{
959 SDL_Event ev; 1032 SDL_Event ev;
960 1033
961 SDL_PumpEvents (); 1034 SDL_PumpEvents ();
… …
1027 1100
1028 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1)))); 1101 XPUSHs (sv_2mortal (sv_bless (newRV_noinc ((SV *)hv), gv_stashpv ("DC::UI::Event", 1))));
1029 } 1102 }
1030} 1103}
1031 1104
1105char *
1106SDL_AudioDriverName ()
1107 CODE:
1108{
1109 char buf [256];
1110 if (!SDL_AudioDriverName (buf, sizeof (buf)))
1111 XSRETURN_UNDEF;
1112
1113 RETVAL = buf;
1114}
1115 OUTPUT:
1116 RETVAL
1117
1032int 1118int
1033Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096) 1119Mix_OpenAudio (int frequency = 44100, int format = MIX_DEFAULT_FORMAT, int channels = 2, int chunksize = 4096)
1034 POSTCALL: 1120 POSTCALL:
1035 Mix_HookMusicFinished (music_finished); 1121 Mix_HookMusicFinished (music_finished);
1036 Mix_ChannelFinished (channel_finished); 1122 Mix_ChannelFinished (channel_finished);
1037 1123
1038void 1124void
1039Mix_QuerySpec () 1125Mix_QuerySpec ()
… …
1098add_font (char *file) 1184add_font (char *file)
1099 CODE: 1185 CODE:
1100 RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file); 1186 RETVAL = FcConfigAppFontAddFile (0, (const FcChar8 *)file);
1101 OUTPUT: 1187 OUTPUT:
1102 RETVAL 1188 RETVAL
1189
1190void
1191IMG_Init (int flags = IMG_INIT_JPG | IMG_INIT_PNG)
1192
1193# MIX_INIT_MP3 gives smpeg + libstdc++ + libgcc_s
1194void
1195Mix_Init (int flags = MIX_INIT_MOD | MIX_INIT_OGG)
1103 1196
1104void 1197void
1105load_image_inline (SV *image_) 1198load_image_inline (SV *image_)
1106 ALIAS: 1199 ALIAS:
1107 load_image_file = 1 1200 load_image_file = 1
… …
1153 1246
1154 SDL_LockSurface (surface2); 1247 SDL_LockSurface (surface2);
1155 EXTEND (SP, 6); 1248 EXTEND (SP, 6);
1156 PUSHs (sv_2mortal (newSViv (surface2->w))); 1249 PUSHs (sv_2mortal (newSViv (surface2->w)));
1157 PUSHs (sv_2mortal (newSViv (surface2->h))); 1250 PUSHs (sv_2mortal (newSViv (surface2->h)));
1158 PUSHs (sv_2mortal (newSVpvn (surface2->pixels, surface2->h * surface2->pitch))); 1251 PUSHs (sv_2mortal (newSVpvn ((const char *)surface2->pixels, surface2->h * surface2->pitch)));
1159 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB))); 1252 PUSHs (sv_2mortal (newSViv (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA) ? GL_RGBA : GL_RGB)));
1160 PUSHs (sv_2mortal (newSViv (GL_RGBA))); 1253 PUSHs (sv_2mortal (newSViv (GL_RGBA)));
1161 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE))); 1254 PUSHs (sv_2mortal (newSViv (GL_UNSIGNED_BYTE)));
1162 SDL_UnlockSurface (surface2); 1255 SDL_UnlockSurface (surface2);
1163 1256
… …
1235MODULE = Deliantra::Client PACKAGE = DC::Font 1328MODULE = Deliantra::Client PACKAGE = DC::Font
1236 1329
1237PROTOTYPES: DISABLE 1330PROTOTYPES: DISABLE
1238 1331
1239DC::Font 1332DC::Font
1240new_from_file (SV *class, char *path, int id = 0) 1333new_from_file (SV *klass, char *path, int id = 0)
1241 CODE: 1334 CODE:
1242{ 1335{
1243 int count; 1336 int count;
1244 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count); 1337 FcPattern *pattern = FcFreeTypeQuery ((const FcChar8 *)path, id, 0, &count);
1245 RETVAL = pango_fc_font_description_from_pattern (pattern, 0); 1338 RETVAL = pango_fc_font_description_from_pattern (pattern, 0);
… …
1274 PROTOTYPE: 1367 PROTOTYPE:
1275 CODE: 1368 CODE:
1276 tc_restore (); 1369 tc_restore ();
1277 1370
1278DC::Layout 1371DC::Layout
1279new (SV *class) 1372new (SV *klass)
1280 CODE: 1373 CODE:
1281 New (0, RETVAL, 1, struct cf_layout); 1374 New (0, RETVAL, 1, struct cf_layout);
1282 1375
1283 RETVAL->pl = pango_layout_new (opengl_context); 1376 RETVAL->pl = pango_layout_new (opengl_context);
1284 RETVAL->r = 1.; 1377 RETVAL->r = 1.;
… …
1433 1526
1434void 1527void
1435set_height (DC::Layout self, int base_height) 1528set_height (DC::Layout self, int base_height)
1436 CODE: 1529 CODE:
1437 if (self->base_height != base_height) 1530 if (self->base_height != base_height)
1438 { 1531 {
1439 self->base_height = base_height; 1532 self->base_height = base_height;
1440 layout_update_font (self); 1533 layout_update_font (self);
1441 } 1534 }
1442 1535
1443void 1536void
… …
1807MODULE = Deliantra::Client PACKAGE = DC::Map 1900MODULE = Deliantra::Client PACKAGE = DC::Map
1808 1901
1809PROTOTYPES: DISABLE 1902PROTOTYPES: DISABLE
1810 1903
1811DC::Map 1904DC::Map
1812new (SV *class) 1905new (SV *klass)
1813 CODE: 1906 CODE:
1814 New (0, RETVAL, 1, struct map); 1907 New (0, RETVAL, 1, mapgrid);
1815 RETVAL->x = 0; 1908 RETVAL->x = 0;
1816 RETVAL->y = 0; 1909 RETVAL->y = 0;
1817 RETVAL->w = 0; 1910 RETVAL->w = 0;
1818 RETVAL->h = 0; 1911 RETVAL->h = 0;
1819 RETVAL->ox = 0; 1912 RETVAL->ox = 0;
… …
1856 1949
1857void 1950void
1858set_smooth (DC::Map self, int face, int smooth, int level) 1951set_smooth (DC::Map self, int face, int smooth, int level)
1859 CODE: 1952 CODE:
1860{ 1953{
1861 tileid texid; 1954 tileid texid;
1862 maptex *tex; 1955 maptex *tex;
1863 1956
1864 if (face < 0 || face >= self->faces) 1957 if (face < 0 || face >= self->faces)
1865 return; 1958 return;
1866 1959
1867 if (smooth < 0 || smooth >= self->faces) 1960 if (smooth < 0 || smooth >= self->faces)
1868 return; 1961 return;
1869 1962
1870 texid = self->face2tile [face]; 1963 texid = self->face2tile [face];
1871 1964
1872 if (!texid) 1965 if (!texid)
1873 return; 1966 return;
1874 1967
1875 tex = self->tex + texid; 1968 tex = self->tex + texid;
… …
1908} 2001}
1909 2002
1910void 2003void
1911expire_textures (DC::Map self, int texid, int count) 2004expire_textures (DC::Map self, int texid, int count)
1912 PPCODE: 2005 PPCODE:
1913 for (; texid < self->texs && count; ++texid, --count) 2006 for (; texid < self->texs && count; ++texid, --count)
1914 { 2007 {
1915 maptex *tex = self->tex + texid; 2008 maptex *tex = self->tex + texid;
1916 2009
1917 if (tex->name) 2010 if (tex->name)
1918 { 2011 {
… …
1973 self->y += MAP_EXTEND_Y; 2066 self->y += MAP_EXTEND_Y;
1974 } 2067 }
1975} 2068}
1976 2069
1977SV * 2070SV *
1978map1a_update (DC::Map self, SV *data_, int extmap) 2071map1a_update (DC::Map self, SV *data_)
1979 CODE: 2072 CODE:
1980{ 2073{
1981 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_); 2074 uint8_t *data = (uint8_t *)SvPVbyte_nolen (data_);
1982 uint8_t *data_end = (uint8_t *)SvEND (data_); 2075 uint8_t *data_end = (uint8_t *)SvEND (data_);
1983 mapcell *cell; 2076 mapcell *cell;
… …
2004 2097
2005 //TODO: don't trust server data to be in-range(!) 2098 //TODO: don't trust server data to be in-range(!)
2006 2099
2007 if (flags & 8) 2100 if (flags & 8)
2008 { 2101 {
2102 uint8_t ext, cmd;
2103
2009 if (extmap) 2104 do
2010 { 2105 {
2011 uint8_t ext, cmd; 2106 ext = *data++;
2107 cmd = ext & 0x7f;
2012 2108
2013 do 2109 if (cmd < 4)
2110 cell->darkness = 255 - ext * 64 + 1; /* make sure this doesn't collide with FOW_DARKNESS */
2111 else if (cmd == 5) // health
2014 { 2112 {
2015 ext = *data++;
2016 cmd = ext & 0x7f;
2017
2018 if (cmd < 4)
2019 cell->darkness = 255 - ext * 64 + 1; /* make sure this doesn't collide with FOW_DARKNESS */
2020 else if (cmd == 5) // health
2021 {
2022 cell->stat_width = 1; 2113 cell->stat_width = 1;
2023 cell->stat_hp = *data++; 2114 cell->stat_hp = *data++;
2024 }
2025 else if (cmd == 6) // monster width
2026 cell->stat_width = *data++ + 1;
2027 else if (cmd == 0x47)
2028 {
2029 if (*data == 1) cell->player = data [1];
2030 else if (*data == 2) cell->player = data [2] + (data [1] << 8);
2031 else if (*data == 3) cell->player = data [3] + (data [2] << 8) + (data [1] << 16);
2032 else if (*data == 4) cell->player = data [4] + (data [3] << 8) + (data [2] << 16) + (data [1] << 24);
2033
2034 data += *data + 1;
2035 }
2036 else if (cmd == 8) // cell flags
2037 cell->flags = *data++;
2038 else if (ext & 0x40) // unknown, multibyte => skip
2039 data += *data + 1;
2040 else
2041 data++;
2042 } 2115 }
2043 while (ext & 0x80); 2116 else if (cmd == 6) // monster width
2117 cell->stat_width = *data++ + 1;
2118 else if (cmd == 0x47)
2119 {
2120 if (*data == 1) cell->player = data [1];
2121 else if (*data == 2) cell->player = data [2] + (data [1] << 8);
2122 else if (*data == 3) cell->player = data [3] + (data [2] << 8) + (data [1] << 16);
2123 else if (*data == 4) cell->player = data [4] + (data [3] << 8) + (data [2] << 16) + (data [1] << 24);
2124
2125 data += *data + 1;
2126 }
2127 else if (cmd == 8) // cell flags
2128 cell->flags = *data++;
2129 else if (ext & 0x40) // unknown, multibyte => skip
2130 data += *data + 1;
2131 else
2132 data++;
2044 } 2133 }
2045 else 2134 while (ext & 0x80);
2046 cell->darkness = *data++ + 1;
2047 } 2135 }
2048 2136
2049 for (z = 0; z <= 2; ++z) 2137 for (z = 0; z <= 2; ++z)
2050 if (flags & (4 >> z)) 2138 if (flags & (4 >> z))
2051 { 2139 {
… …
2099 ? self->row + y 2187 ? self->row + y
2100 : 0; 2188 : 0;
2101 2189
2102 for (x = x0; x < x1; x++) 2190 for (x = x0; x < x1; x++)
2103 { 2191 {
2104 int r = 32, g = 32, b = 32, a = 192; 2192 unsigned int r = 32, g = 32, b = 32, a = 192;
2105 2193
2106 if (row && row->c0 <= x && x < row->c1) 2194 if (row && row->c0 <= x && x < row->c1)
2107 { 2195 {
2108 mapcell *cell = row->col + (x - row->c0); 2196 mapcell *cell = row->col + (x - row->c0);
2109 2197
… …
2111 { 2199 {
2112 maptex tex = self->tex [cell->tile [z]]; 2200 maptex tex = self->tex [cell->tile [z]];
2113 int a0 = 255 - tex.a; 2201 int a0 = 255 - tex.a;
2114 int a1 = tex.a; 2202 int a1 = tex.a;
2115 2203
2116 r = (r * a0 + tex.r * a1) / 255; 2204 r = div255 (r * a0 + tex.r * a1);
2117 g = (g * a0 + tex.g * a1) / 255; 2205 g = div255 (g * a0 + tex.g * a1);
2118 b = (b * a0 + tex.b * a1) / 255; 2206 b = div255 (b * a0 + tex.b * a1);
2119 a = (a * a0 + tex.a * a1) / 255; 2207 a = div255 (a * a0 + tex.a * a1);
2120 } 2208 }
2121 } 2209 }
2122 2210
2123 *map++ = (r ) 2211 *map++ = (r )
2124 | (g << 8) 2212 | (g << 8)
2125 | (b << 16) 2213 | (b << 16)
2126 | (a << 24); 2214 | (a << 24);
2127 } 2215 }
2128 } 2216 }
2129 2217
2130 RETVAL = map_sv; 2218 RETVAL = map_sv;
2131} 2219}
2132 OUTPUT: 2220 OUTPUT:
2133 RETVAL 2221 RETVAL
2134 2222
2135void 2223void
2136draw (DC::Map self, int mx, int my, int sw, int sh, int T, U32 player = 0xffffffff, int sdx = 0, int sdy = 0) 2224draw (DC::Map self, int mx, int my, int sw, int sh, int Tw, int Th, U32 player = 0xffffffff, int sdx = 0, int sdy = 0)
2137 CODE: 2225 CODE:
2138{ 2226{
2139 int x, y, z; 2227 int x, y, z;
2140 2228
2141 HV *smooth = (HV *)sv_2mortal ((SV *)newHV ());
2142 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
2143 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k) 2229 static uint8_t smooth_max[256][256]; // egad, fast and wasteful on memory (64k), also, static!
2144 smooth_key skey;
2145 int pl_x, pl_y; 2230 int pl_x, pl_y;
2146 maptex pl_tex; 2231 maptex pl_tex;
2147 rc_t *rc = rc_alloc (); 2232 rc_t *rc = rc_alloc ();
2148 rc_t *rc_ov = rc_alloc (); 2233 rc_t *rc_ov = rc_alloc ();
2149 rc_key_t key; 2234 rc_key_t key;
… …
2152 pl_tex.name = 0; 2237 pl_tex.name = 0;
2153 2238
2154 // that's current max. sorry. 2239 // that's current max. sorry.
2155 if (sw > 255) sw = 255; 2240 if (sw > 255) sw = 255;
2156 if (sh > 255) sh = 255; 2241 if (sh > 255) sh = 255;
2157
2158 // clear key, in case of extra padding
2159 memset (&skey, 0, sizeof (skey));
2160 2242
2161 memset (&key, 0, sizeof (key)); 2243 memset (&key, 0, sizeof (key));
2162 key.r = 255; 2244 key.r = 255;
2163 key.g = 255; 2245 key.g = 255;
2164 key.b = 255; 2246 key.b = 255;
… …
2170 my += self->y; 2252 my += self->y;
2171 2253
2172 // first pass: determine smooth_max 2254 // first pass: determine smooth_max
2173 // rather ugly, if you ask me 2255 // rather ugly, if you ask me
2174 // could also be stored inside mapcell and updated on change 2256 // could also be stored inside mapcell and updated on change
2175 memset (smooth_max, 0, sizeof (smooth_max)); 2257 memset (smooth_max, 0, sizeof (smooth_max[0]) * (sh + 1));
2176 2258
2177 for (y = 0; y < sh; y++) 2259 for (y = 0; y < sh; y++)
2178 if (0 <= y + my && y + my < self->rows) 2260 if (0 <= y + my && y + my < self->rows)
2179 { 2261 {
2180 maprow *row = self->row + (y + my); 2262 maprow *row = self->row + (y + my);
… …
2195 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 2277 glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2196 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2278 glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
2197 2279
2198 for (z = 0; z <= 2; z++) 2280 for (z = 0; z <= 2; z++)
2199 { 2281 {
2282 uint32_t smooth_level[256 / 32]; // one bit for every possible smooth level
2283 smooth_key skey;
2284 smooth_hash smooth;
2200 memset (smooth_level, 0, sizeof (smooth_level)); 2285 memset (smooth_level, 0, sizeof (smooth_level));
2201 key.texname = -1; 2286 key.texname = -1;
2202 2287
2203 for (y = 0; y < sh; y++) 2288 for (y = 0; y < sh; y++)
2204 if (0 <= y + my && y + my < self->rows) 2289 if (0 <= y + my && y + my < self->rows)
… …
2225 2310
2226 key.texname = tex.name; 2311 key.texname = tex.name;
2227 arr = rc_array (rc, &key); 2312 arr = rc_array (rc, &key);
2228 } 2313 }
2229 2314
2230 px = (x + 1) * T - tex.w; 2315 px = (x + 1) * Th - tex.w;
2231 py = (y + 1) * T - tex.h; 2316 py = (y + 1) * Tw - tex.h;
2232 2317
2233 if (expect_false (cell->player == player) && expect_false (z == 2)) 2318 if (expect_false (cell->player == player) && expect_false (z == 2))
2234 { 2319 {
2235 pl_x = px; 2320 pl_x = px;
2236 pl_y = py; 2321 pl_y = py;
… …
2265 2350
2266 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ·· 2351 // corners: 1 ┛· 2 ·┗ 4 ·· 8 ··
2267 // ·· ·· ·┏ ┓· 2352 // ·· ·· ·┏ ┓·
2268 2353
2269 // full tile 2354 // full tile
2270 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x1000); 2355 skey.x = x + 1; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x1000);
2271 2356
2272 // borders 2357 // borders
2273 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0091); 2358 skey.x = x + 2; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0091);
2274 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0032); 2359 skey.x = x + 1; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0032);
2275 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, &skey, 0x0064); 2360 skey.x = x ; skey.y = y + 1; smooth_or_bits (smooth, skey, 0x0064);
2276 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, &skey, 0x00c8); 2361 skey.x = x + 1; skey.y = y ; smooth_or_bits (smooth, skey, 0x00c8);
2277 2362
2278 // corners 2363 // corners
2279 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0100); 2364 skey.x = x + 2; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0100);
2280 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, &skey, 0x0200); 2365 skey.x = x ; skey.y = y + 2; smooth_or_bits (smooth, skey, 0x0200);
2281 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0400); 2366 skey.x = x ; skey.y = y ; smooth_or_bits (smooth, skey, 0x0400);
2282 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, &skey, 0x0800); 2367 skey.x = x + 2; skey.y = y ; smooth_or_bits (smooth, skey, 0x0800);
2283 } 2368 }
2284 } 2369 }
2285 2370
2286 if (expect_false (z == 2) && expect_false (cell->flags)) 2371 if (expect_false (z == 2) && expect_false (cell->flags))
2287 { 2372 {
… …
2289 if (cell->flags & 1) 2374 if (cell->flags & 1)
2290 { 2375 {
2291 rc_key_t key_ov = key; 2376 rc_key_t key_ov = key;
2292 maptex tex = self->tex [TEXID_SPEECH]; 2377 maptex tex = self->tex [TEXID_SPEECH];
2293 rc_array_t *arr; 2378 rc_array_t *arr;
2294 int px = x * T + T * 2 / 32; 2379 int px = x * Tw + Tw * 2 / 32;
2295 int py = y * T - T * 6 / 32; 2380 int py = y * Th - Th * 6 / 32;
2296 2381
2297 key_ov.texname = tex.name; 2382 key_ov.texname = tex.name;
2298 arr = rc_array (rc_ov, &key_ov); 2383 arr = rc_array (rc_ov, &key_ov);
2299 2384
2300 rc_t2f_v3f (arr, 0 , 0 , px , py , 0); 2385 rc_t2f_v3f (arr, 0 , 0 , px , py , 0);
2301 rc_t2f_v3f (arr, 0 , tex.t, px , py + T, 0); 2386 rc_t2f_v3f (arr, 0 , tex.t, px , py + Th, 0);
2302 rc_t2f_v3f (arr, tex.s, tex.t, px + T, py + T, 0); 2387 rc_t2f_v3f (arr, tex.s, tex.t, px + Tw, py + Th, 0);
2303 rc_t2f_v3f (arr, tex.s, 0 , px + T, py , 0); 2388 rc_t2f_v3f (arr, tex.s, 0 , px + Tw, py , 0);
2304 } 2389 }
2305 } 2390 }
2306 } 2391 }
2307 } 2392 }
2308 2393
… …
2324 if (smask & (((uint32_t)1) << b)) 2409 if (smask & (((uint32_t)1) << b))
2325 { 2410 {
2326 int level = (w << 5) | b; 2411 int level = (w << 5) | b;
2327 HE *he; 2412 HE *he;
2328 2413
2329 hv_iterinit (smooth); 2414 for (auto &&it = smooth.begin (); it != smooth.end (); ++it)
2330 while ((he = hv_iternext (smooth)))
2331 { 2415 {
2332 smooth_key *skey = (smooth_key *)HeKEY (he); 2416 smooth_key &skey = it->first;
2333 IV bits = SvIVX (HeVAL (he)); 2417 IV bits = it->second;
2334 2418
2335 if (!(bits & 0x1000) 2419 if (!(bits & 0x1000)
2336 && skey->level == level 2420 && skey.level == level
2337 && level > smooth_max [skey->x][skey->y]) 2421 && level > smooth_max [skey.x][skey.y])
2338 { 2422 {
2339 maptex tex = self->tex [skey->tile]; 2423 maptex tex = self->tex [skey.tile];
2340 int px = (((int)skey->x) - 1) * T; 2424 int px = (((int)skey.x) - 1) * Tw;
2341 int py = (((int)skey->y) - 1) * T; 2425 int py = (((int)skey.y) - 1) * Th;
2342 int border = bits & 15; 2426 int border = bits & 15;
2343 int corner = (bits >> 8) & ~(bits >> 4) & 15; 2427 int corner = (bits >> 8) & ~(bits >> 4) & 15;
2344 float dx = tex.s * .0625f; // 16 images/row 2428 float dx = tex.s * .0625f; // 16 images/row
2345 float dy = tex.t * .5f ; // 2 images/column 2429 float dy = tex.t * .5f ; // 2 images/column
2346 2430
… …
2348 { 2432 {
2349 // this time avoiding texture state changes 2433 // this time avoiding texture state changes
2350 // save gobs of state changes. 2434 // save gobs of state changes.
2351 if (key.texname != tex.name) 2435 if (key.texname != tex.name)
2352 { 2436 {
2353 self->tex [skey->tile].unused = 0; 2437 self->tex [skey.tile].unused = 0;
2354 2438
2355 glEnd (); 2439 glEnd ();
2356 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name); 2440 glBindTexture (GL_TEXTURE_2D, key.texname = tex.name);
2357 glBegin (GL_QUADS); 2441 glBegin (GL_QUADS);
2358 } 2442 }
2359 2443
2360 if (border) 2444 if (border)
2361 { 2445 {
2362 float ox = border * dx; 2446 float ox = border * dx;
2363 2447
2364 glTexCoord2f (ox , 0.f ); glVertex2i (px , py ); 2448 glTexCoord2f (ox , 0.f ); glVertex2i (px , py );
2365 glTexCoord2f (ox , dy ); glVertex2i (px , py + T); 2449 glTexCoord2f (ox , dy ); glVertex2i (px , py + Th);
2366 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py + T); 2450 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py + Th);
2367 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + T, py ); 2451 glTexCoord2f (ox + dx, 0.f ); glVertex2i (px + Tw, py );
2368 } 2452 }
2369 2453
2370 if (corner) 2454 if (corner)
2371 { 2455 {
2372 float ox = corner * dx; 2456 float ox = corner * dx;
2373 2457
2374 glTexCoord2f (ox , dy ); glVertex2i (px , py ); 2458 glTexCoord2f (ox , dy ); glVertex2i (px , py );
2375 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + T); 2459 glTexCoord2f (ox , dy * 2.f); glVertex2i (px , py + Th);
2376 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + T, py + T); 2460 glTexCoord2f (ox + dx, dy * 2.f); glVertex2i (px + Tw, py + Th);
2377 glTexCoord2f (ox + dx, dy ); glVertex2i (px + T, py ); 2461 glTexCoord2f (ox + dx, dy ); glVertex2i (px + Tw, py );
2378 } 2462 }
2379 } 2463 }
2380 } 2464 }
2381 } 2465 }
2382 } 2466 }
… …
2384 2468
2385 glEnd (); 2469 glEnd ();
2386 glDisable (GL_TEXTURE_2D); 2470 glDisable (GL_TEXTURE_2D);
2387 key.texname = -1; 2471 key.texname = -1;
2388 } 2472 }
2389
2390 hv_clear (smooth);
2391 } 2473 }
2392 2474
2393 if (pl_tex.name) 2475 if (pl_tex.name)
2394 { 2476 {
2395 maptex tex = pl_tex; 2477 maptex tex = pl_tex;
… …
2423 for (x = 0; x < sw; x++) 2505 for (x = 0; x < sw; x++)
2424 if (row->c0 <= x + mx && x + mx < row->c1) 2506 if (row->c0 <= x + mx && x + mx < row->c1)
2425 { 2507 {
2426 mapcell *cell = row->col + (x + mx - row->c0); 2508 mapcell *cell = row->col + (x + mx - row->c0);
2427 2509
2428 int px = x * T; 2510 int px = x * Tw;
2429 int py = y * T; 2511 int py = y * Th;
2430 2512
2431 if (expect_false (cell->player == player)) 2513 if (expect_false (cell->player == player))
2432 { 2514 {
2433 px += sdx; 2515 px += sdx;
2434 py += sdy; 2516 py += sdy;
2435 } 2517 }
2436 2518
2437 if (cell->stat_hp) 2519 if (cell->stat_hp)
2438 { 2520 {
2439 int width = cell->stat_width * T; 2521 int width = cell->stat_width * Tw;
2440 int thick = (sh * T / 32 + 27) / 28 + 1 + cell->stat_width; 2522 int thick = (sh * Th / 32 + 27) / 28 + 1 + cell->stat_width;
2441 2523
2442 glColor3ub (0, 0, 0); 2524 glColor3ub (0, 0, 0);
2443 glRectf (px + 1, py - thick - 2, 2525 glRectf (px + 1, py - thick - 2,
2444 px + width - 1, py); 2526 px + width - 1, py);
2445 2527
… …
2525 int x, y; 2607 int x, y;
2526 int sw1 = sw + 2; 2608 int sw1 = sw + 2;
2527 int sh1 = sh + 2; 2609 int sh1 = sh + 2;
2528 int sh3 = sh * 3; 2610 int sh3 = sh * 3;
2529 int sw3 = sw * 3; 2611 int sw3 = sw * 3;
2530 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2531 SV *darkness3_sv = sv_2mortal (newSV (sw3 * sh3)); 2612 SV *darkness3_sv = sv_2mortal (newSV (sw3 * sh3));
2532 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv); 2613 uint8_t *darkness3 = (uint8_t *)SvPVX (darkness3_sv);
2614 uint8_t *darkness1 = (uint8_t *)malloc (sw1 * sh1);
2615 memset (darkness1, 0, sw1*sh1);
2533 2616
2534 SvPOK_only (darkness3_sv); 2617 SvPOK_only (darkness3_sv);
2535 SvCUR_set (darkness3_sv, sw3 * sh3); 2618 SvCUR_set (darkness3_sv, sw3 * sh3);
2536 2619
2537 mx += self->x - 1; 2620 mx += self->x - 1;
… …
2663 else 2746 else
2664 *data++ = 0; 2747 *data++ = 0;
2665 } 2748 }
2666 } 2749 }
2667 2750
2668 /* if size is w*h + 5 then no data has been found */ 2751 /* if size is w*h + 5 then no data has been found */
2669 if (data - (uint8_t *)SvPVX (data_sv) != w * h + 5) 2752 if (data - (uint8_t *)SvPVX (data_sv) != w * h + 5)
2670 { 2753 {
2671 SvPOK_only (data_sv); 2754 SvPOK_only (data_sv);
2672 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv)); 2755 SvCUR_set (data_sv, data - (uint8_t *)SvPVX (data_sv));
2673 } 2756 }
2674 2757
2675 RETVAL = data_sv; 2758 RETVAL = data_sv;
2676} 2759}
2677 OUTPUT: 2760 OUTPUT:
2678 RETVAL 2761 RETVAL
2679 2762
2680void 2763void
… …
2687 STRLEN len; 2770 STRLEN len;
2688 uint8_t *data, *end; 2771 uint8_t *data, *end;
2689 2772
2690 len = SvLEN (data_sv); 2773 len = SvLEN (data_sv);
2691 SvGROW (data_sv, len + 8); // reserve at least 7+ bytes more 2774 SvGROW (data_sv, len + 8); // reserve at least 7+ bytes more
2692 data = SvPVbyte_nolen (data_sv); 2775 data = (uint8_t *)SvPVbyte_nolen (data_sv);
2693 end = data + len + 8; 2776 end = data + len + 8;
2694 2777
2695 if (len < 5) 2778 if (len < 5)
2696 XSRETURN_EMPTY; 2779 XSRETURN_EMPTY;
2697 2780
… …
2758} 2841}
2759 2842
2760MODULE = Deliantra::Client PACKAGE = DC::RW 2843MODULE = Deliantra::Client PACKAGE = DC::RW
2761 2844
2762DC::RW 2845DC::RW
2763new (SV *class, SV *data_sv) 2846new (SV *klass, SV *data_sv)
2764 CODE: 2847 CODE:
2765{ 2848{
2766 STRLEN datalen; 2849 STRLEN datalen;
2767 char *data = SvPVbyte (data_sv, datalen); 2850 char *data = SvPVbyte (data_sv, datalen);
2768 2851
… …
2770} 2853}
2771 OUTPUT: 2854 OUTPUT:
2772 RETVAL 2855 RETVAL
2773 2856
2774DC::RW 2857DC::RW
2775new_from_file (SV *class, const char *path, const char *mode = "rb") 2858new_from_file (SV *klass, const char *path, const char *mode = "rb")
2776 CODE: 2859 CODE:
2777 RETVAL = SDL_RWFromFile (path, mode); 2860 RETVAL = SDL_RWFromFile (path, mode);
2778 OUTPUT: 2861 OUTPUT:
2779 RETVAL 2862 RETVAL
2780 2863
… …
2889#else 2972#else
2890 XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0))); 2973 XPUSHs (sv_2mortal (newSVpv ("(sdl mixer too old)", 0)));
2891#endif 2974#endif
2892 2975
2893DC::MixChunk 2976DC::MixChunk
2894new (SV *class, DC::RW rwops) 2977new (SV *klass, DC::RW rwops)
2895 CODE: 2978 CODE:
2896 RETVAL = Mix_LoadWAV_RW (rwops, 1); 2979 RETVAL = Mix_LoadWAV_RW (rwops, 1);
2897 OUTPUT: 2980 OUTPUT:
2898 RETVAL 2981 RETVAL
2899 2982
… …
2969 RETVAL = Mix_PlayingMusic (); 3052 RETVAL = Mix_PlayingMusic ();
2970 OUTPUT: 3053 OUTPUT:
2971 RETVAL 3054 RETVAL
2972 3055
2973DC::MixMusic 3056DC::MixMusic
2974new (SV *class, DC::RW rwops) 3057new (SV *klass, DC::RW rwops)
2975 CODE: 3058 CODE:
2976 RETVAL = Mix_LoadMUS_RW (rwops); 3059 RETVAL = Mix_LoadMUS_RW (rwops);
2977 OUTPUT: 3060 OUTPUT:
2978 RETVAL 3061 RETVAL
2979 3062
… …
3116 const_iv (GL_FUNC_SUBTRACT), 3199 const_iv (GL_FUNC_SUBTRACT),
3117 const_iv (GL_FUNC_REVERSE_SUBTRACT), 3200 const_iv (GL_FUNC_REVERSE_SUBTRACT),
3118# undef const_iv 3201# undef const_iv
3119 }; 3202 };
3120 3203
3121 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 3204 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ > const_iv; civ--)
3122 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 3205 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
3123 3206
3124 texture_av = newAV (); 3207 texture_av = newAV ();
3125 AvREAL_off (texture_av); 3208 AvREAL_off (texture_av);
3126} 3209}
3127 3210
… …
3132 gl.BlendFuncSeparateEXT = 0; 3215 gl.BlendFuncSeparateEXT = 0;
3133 3216
3134void 3217void
3135apple_nvidia_bug (int enable) 3218apple_nvidia_bug (int enable)
3136 3219
3137char * 3220const char *
3138gl_vendor () 3221gl_vendor ()
3139 CODE: 3222 CODE:
3140 RETVAL = (char *)glGetString (GL_VENDOR); 3223 RETVAL = (const char *)glGetString (GL_VENDOR);
3141 OUTPUT: 3224 OUTPUT:
3142 RETVAL 3225 RETVAL
3143 3226
3144char * 3227const char *
3145gl_version () 3228gl_version ()
3146 CODE: 3229 CODE:
3147 RETVAL = (char *)glGetString (GL_VERSION); 3230 RETVAL = (const char *)glGetString (GL_VERSION);
3148 OUTPUT: 3231 OUTPUT:
3149 RETVAL 3232 RETVAL
3150 3233
3151char * 3234const char *
3152gl_extensions () 3235gl_extensions ()
3153 CODE: 3236 CODE:
3154 RETVAL = (char *)glGetString (GL_EXTENSIONS); 3237 RETVAL = (const char *)glGetString (GL_EXTENSIONS);
3155 OUTPUT: 3238 OUTPUT:
3156 RETVAL 3239 RETVAL
3157 3240
3158const char *glGetString (GLenum pname) 3241const char *glGetString (GLenum pname)
3242 CODE:
3243 RETVAL = (const char *)glGetString (pname);
3244 OUTPUT:
3245 RETVAL
3159 3246
3160GLint glGetInteger (GLenum pname) 3247GLint glGetInteger (GLenum pname)
3161 CODE: 3248 CODE:
3162 glGetIntegerv (pname, &RETVAL); 3249 glGetIntegerv (pname, &RETVAL);
3163 OUTPUT: 3250 OUTPUT:
… …
3170 RETVAL 3257 RETVAL
3171 3258
3172int glGetError () 3259int glGetError ()
3173 3260
3174void glFinish () 3261void glFinish ()
3262
3263void glFlush ()
3175 3264
3176void glClear (int mask) 3265void glClear (int mask)
3177 3266
3178void glClearColor (float r, float g, float b, float a = 1.0) 3267void glClearColor (float r, float g, float b, float a = 1.0)
3179 PROTOTYPE: @ 3268 PROTOTYPE: @
… …
3364 3453
3365void 3454void
3366find_widget (SV *self, NV x, NV y) 3455find_widget (SV *self, NV x, NV y)
3367 PPCODE: 3456 PPCODE:
3368{ 3457{
3369 if (within_widget (self, x, y)) 3458 if (within_widget (self, x, y))
3370 XPUSHs (self); 3459 XPUSHs (self);
3371} 3460}
3372 3461
3373BOOT: 3462BOOT:
3374{ 3463{
… …
3382 3471
3383void 3472void
3384draw (SV *self) 3473draw (SV *self)
3385 CODE: 3474 CODE:
3386{ 3475{
3387 HV *hv; 3476 HV *hv;
3388 SV **svp; 3477 SV **svp;
3389 NV x, y, w, h; 3478 NV x, y, w, h;
3390 SV *draw_x_sv = GvSV (draw_x_gv); 3479 SV *draw_x_sv = GvSV (draw_x_gv);
3391 SV *draw_y_sv = GvSV (draw_y_gv); 3480 SV *draw_y_sv = GvSV (draw_y_gv);
3392 SV *draw_w_sv = GvSV (draw_w_gv); 3481 SV *draw_w_sv = GvSV (draw_w_gv);
3393 SV *draw_h_sv = GvSV (draw_h_gv); 3482 SV *draw_h_sv = GvSV (draw_h_gv);

Diff Legend

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