source: abuse/trunk/src/imlib/morph.cpp @ 57

Last change on this file since 57 was 56, checked in by Sam Hocevar, 14 years ago
  • Add licensing terms to most C / C++ files (Ref #5).
File size: 25.5 KB
Line 
1/*
2 *  Abuse - dark 2D side-scrolling platform game
3 *  Copyright (c) 1995 Crack dot Com
4 *
5 *  This software was released into the Public Domain. As with most public
6 *  domain software, no warranty is made or implied by Crack dot Com or
7 *  Jonathan Clark.
8 */
9
10#include "config.h"
11
12#include "morph.hpp"
13
14long trans(long x1, long x2, long frame)
15{
16  return (((x2-x1)<<5)*frame+(x1<<8))>>8; 
17}
18
19
20void jmorph::show_step_frame(image *screen, int x, int y, int frame_on,
21                       color_filter *fli, palette *pal)
22{
23  short x1,y1,x2,y2;
24  unsigned char r1,g1,b1,r2,g2,b2;
25  screen->get_clip(x1,y1,x2,y2);
26 
27  int i;
28  long xx,yy;
29 
30  if (small)
31  {
32    morph_point8 *m8=(morph_point8 *)p;
33    for (i=0;i<total;i++,m8++)
34    {
35      xx=x+trans(m8->x1,m8->x2,frame_on);
36      yy=y+trans(m8->y1,m8->y2,frame_on);
37     
38      if (xx>=x1 && xx<=x2 && yy>=y1 && yy<=y2)
39      {
40        pal->get(m8->start_color,r1,g1,b1);
41        pal->get(m8->end_color,r2,g2,b2);
42 
43        long r=trans(r1,r2,frame_on)>>3,
44             g=trans(g1,g2,frame_on)>>3,
45             b=trans(b1,b2,frame_on)>>3;
46       
47        *(screen->scan_line(yy)+xx)=fli->lookup_color(r,g,b);
48      }           
49    }
50  }   
51}
52
53
54void patched_morph::show_frame(image *screen, int x, int y,
55                               int frame_on, color_filter *fli, palette *pal)
56{
57  jmorph::show_step_frame(screen,x,y,frame_on,fli,pal);
58  int tot=pats[frame_on].patches,xx,yy;
59  unsigned char *p=pats[frame_on].patch_data;
60  short cx1,cy1,cx2,cy2;
61  screen->get_clip(cx1,cy1,cx2,cy2);   
62  while (tot--)
63  {
64    xx=*(p++)+x;
65    if (xx<cx1 || xx>cx2)
66      p+=2;
67    else
68    {
69      yy=*(p++)+y;
70      if (yy<cy1 || yy>cy2)
71        p++;
72      else
73        *(screen->scan_line(yy)+xx)=*(p++);
74    }
75  }     
76}
77
78void patched_morph::show_8(image *screen, int x, int y, int frame_on, color_filter *fli, palette *pal)
79{
80  jmorph::show_8(screen,x,y,frame_on,fli,pal);
81  int tot=pats[frame_on].patches,xx,yy;
82  unsigned char *p=pats[frame_on].patch_data;
83  short cx1,cy1,cx2,cy2;
84  screen->get_clip(cx1,cy1,cx2,cy2);   
85  while (tot--)
86  {
87    xx=*(p++)+x;
88    if (xx<cx1 || xx>cx2)
89      p+=2;
90    else
91    {
92      yy=*(p++)+y;
93      if (yy<cy1 || yy>cy2)
94        p++;
95      else
96        *(screen->scan_line(yy)+xx)=*(p++);
97    }
98  }     
99}
100
101
102
103
104patched_morph::patched_morph(image *i1, image *hint1, image *i2, image *hint2, int aneal_steps,
105                color_filter *fli, palette *pal, int frames) : jmorph(i1,hint1,i2,hint2,aneal_steps)
106{
107  int i,j,w,h,x,y,tot,r,g,b,mark_color,dist;
108  unsigned char *cur_patch,*sl,ored,og,ob;
109 
110  frames=9;
111 
112  patches=frames; 
113  pats=(morph_patch *)jmalloc(sizeof(morph_patch)*patches,"morph::patch array");
114  w=max(bound_x2(0),bound_x2(1));
115  h=max(bound_y2(0),bound_y2(1));   
116  image *im=new image(w,h);
117
118
119  for (i=0;i<patches;i++)
120  {
121    pats[i].patch_data=NULL;
122    pats[i].patches=0;   
123    if (i!=0 && i!=patches-1)
124    {     
125      im->clear();
126      jmorph::show_step_frame(im,0,0,i,fli,pal);
127      for (j=0;j<4;j++)
128      {     
129        for (y=0;y<h;y++)
130          for (sl=im->scan_line(y),x=0;x<w;x++,sl++)
131          {     
132            mark_color=-1;
133           
134            tot=r=g=b=0;                 
135            if (x!=0 && *(sl-1))
136            { tot++;
137              r+=pal->red(*(sl-1));
138              g+=pal->green(*(sl-1));
139              b+=pal->blue(*(sl-1));               
140            }     
141            if (x!=w-1 && *(sl+1))
142            { tot++;
143              r+=pal->red(*(sl+1));
144              g+=pal->green(*(sl+1));
145              b+=pal->blue(*(sl+1));   
146            }     
147            if (y!=0 && im->pixel(x,y-1))
148            { tot++;
149              r+=pal->red(im->pixel(x,y-1));
150              g+=pal->green(im->pixel(x,y-1));
151              b+=pal->blue(im->pixel(x,y-1));
152            }
153            if (y!=h-1 && im->pixel(x,y+1))
154            { tot++;
155              r+=pal->red(im->pixel(x,y+1));
156              g+=pal->green(im->pixel(x,y+1));
157              b+=pal->blue(im->pixel(x,y+1));
158            }
159
160            if (*sl && tot==0)  // kill any seperate pixels         
161              mark_color=0;
162            else if (*sl)
163            {
164              pal->get(*sl,ored,og,ob);       // see if we need to blur this on in
165              r/=tot;
166              g/=tot;
167              b/=tot;
168             
169              dist=((int)ored-r)*((int)ored-r)+((int)og-g)*((int)og-g)+((int)ob-b)*((int)ob-b);
170              if (i>0 && i<patches-1 && dist>3000)
171              {
172//              printf("adding blur at %d %d to frame %d, dist=%d\n",x,y,i,dist);
173                mark_color=fli->lookup_color(r>>3,g>>3,b>>3);       
174              }
175            }
176            else if (*sl==0 && tot>=3)     
177              mark_color=fli->lookup_color((r/tot)>>3,(g/tot)>>3,(b/tot)>>3);       
178            if (mark_color>=0)
179            {         
180              pats[i].patches++;
181              pats[i].patch_data=(unsigned char *)realloc(pats[i].patch_data,3*pats[i].patches);
182              cur_patch=pats[i].patch_data+  (pats[i].patches-1)*3;         
183              *(cur_patch++)=x;
184              *(cur_patch++)=y;
185              *sl=mark_color;         
186              *(cur_patch++)=*sl;             
187            }     
188          }
189      }     
190    }
191  } 
192  delete im;
193 
194}
195
196
197void jmorph::show_8(image *screen, int x, int y, int frame_on, color_filter *fli, palette *pal)
198{
199  int pixelx,pixely,i;
200  short cx1,cy1,cx2,cy2;
201  unsigned char r,g,b;
202  unsigned char *scolor,*ecolor,*addr=(unsigned char *)pal->addr();
203  screen->get_clip(cx1,cy1,cx2,cy2);
204
205  if (small)
206  {
207    morph_point8 *p_on=(morph_point8 *)p;
208    for (i=0;i<total;i++,p_on++)
209    {
210      pixelx=(long)((int)p_on->x2-(int)p_on->x1)*(long)frame_on/8+p_on->x1+x;
211      pixely=(long)((int)p_on->y2-(int)p_on->y1)*(long)frame_on/8+p_on->y1+y;
212      if (pixelx>=cx1 && pixely>=cy1 && pixelx<=cx2 && pixely<=cy2)
213      {
214        scolor=addr+((int)p_on->start_color)*3;
215        ecolor=addr+((int)p_on->end_color)*3;
216        r=(((int)*(ecolor++))-((int)*scolor))*frame_on/8+*scolor; scolor++;
217        g=(((int)*(ecolor++))-((int)*scolor))*frame_on/8+*scolor; scolor++;
218        b=((int)(*ecolor)-(int)(*scolor))*frame_on/8+*scolor;
219        *(screen->scan_line(pixely)+pixelx)=fli->lookup_color(r>>3,g>>3,b>>3);
220      }
221    }
222  }
223  else
224  {
225    morph_point16 *p_on=(morph_point16 *)p;
226    for (i=0;i<total;i++,p_on++)
227    {
228      pixelx=(long)((int)p_on->x2-(int)p_on->x1)*(long)frame_on/8+p_on->x1+x;
229      pixely=(long)((int)p_on->y2-(int)p_on->y1)*(long)frame_on/8+p_on->y1+y;
230      if (pixelx>=cx1 && pixely>=cy1 && pixelx<=cx2 && pixely<=cy2)
231      {
232        scolor=addr+((int)p_on->start_color)*3;
233        ecolor=addr+((int)p_on->end_color)*3;
234        r=(((int)*(ecolor++))-((int)*scolor))*frame_on/8+*scolor; scolor++;
235        g=(((int)*(ecolor++))-((int)*scolor))*frame_on/8+*scolor; scolor++;
236        b=((int)(*ecolor)-(int)(*scolor))*frame_on/8+*scolor;
237        *(screen->scan_line(pixely)+pixelx)=fli->lookup_color(r>>3,g>>3,b>>3);
238      }
239    }
240  }
241
242
243
244void jmorph::add_filler(int frames)
245{
246  int w=max(bound_x2(0),bound_x2(1)),h=max(bound_y2(0),bound_y2(1)),
247      i,pixelx,pixely,k,l,frame_on; 
248  morph_point8 **middle_map,*other;
249  unsigned char *end_map;
250  CONDITION(small,"add filler not defined for 16bit morphs\n");
251 
252  if (frames<3) return ;
253 
254
255  middle_map=(morph_point8 **)jmalloc(w*h*sizeof(morph_point8 *),
256                                      "morph::middle_map");  // create an image of pointers
257  end_map=(unsigned char *)jmalloc(w*h,
258                                  "morph::end_map");      // maps all the ending pixels
259
260  for (frame_on=2;frame_on<frames-1;frame_on++)
261  {   
262    memset(middle_map,0,w*h*sizeof(morph_point8 *));            // initialize them middle pointers NULL
263    memset(end_map,0,w*h);                                      // clear all end pixels
264 
265    morph_point8 *p_on=(morph_point8 *)p;    // p is the array of morph points
266    for (i=0;i<total;i++,p_on++)           
267    {   
268      pixelx=(long)((int)p_on->x2-(int)p_on->x1)*(long) frame_on  /(long) frames  +p_on->x1;
269      pixely=(long)((int)p_on->y2-(int)p_on->y1)*(long) frame_on  /(long) frames  +p_on->y1;
270
271      middle_map[pixelx+pixely*w]=p_on;      // map this poisiton back to the morph point
272      end_map[p_on->x2+p_on->y2*w]=p_on->end_color;        // note an ending map here
273    }
274
275 
276    int skipped=0;
277   
278    for (pixely=0;pixely<h;pixely++)
279    {
280      for (pixelx=0;pixelx<w;pixelx++)
281      {
282        if (middle_map[pixelx+pixely*w]==NULL)  // we are checking for 'duds'  (misplaced black pixels)
283        {       
284          int tot;     
285          if (pixelx>0) if (middle_map[pixelx-1+pixely*w]) tot=1; else tot=0;     
286          if (pixelx<w-1) if (middle_map[pixelx+1+pixely*w]) tot++;     
287          if (pixely>0) if (middle_map[pixelx+(pixely-1)*w]) tot++;     
288          if (pixely<h-1) if (middle_map[pixelx+(pixely+1)*w]) tot++;   
289
290          if (tot>=3)                   // it is surronded by 3 non black squares, this is a dud       
291          {
292            int distance,shortest_distance,shortest_end_x,shortest_end_y;         
293            morph_point8 *shortest=NULL;
294           
295            for (k=0;k<w;k++)
296              for (l=0;l<h;l++)
297              {             
298                other=middle_map[k+(l)*w];
299                if (other)
300                {
301                  int end_x=frames*(pixelx-other->x1)/frame_on+other->x1,
302                      end_y=frames*(pixely-other->y1)/frame_on+other->y1;                 
303                  if (end_x>=0 && end_y>=0 && end_x<w && end_y<h && end_map[end_x+end_y*w])
304                  {
305                    distance=(other->x1-end_x)*(other->x1-end_x)+
306                             (other->y1-end_y)*(other->y1-end_y);
307                    if (!shortest || shortest_distance>distance)
308                    {
309                      shortest_distance=distance;
310                      shortest=other;
311                      shortest_end_x=end_x;
312                      shortest_end_y=end_y;                   
313                    }
314                  }
315                }
316              }     
317            if (shortest)
318            {
319              total++;
320              p=(void *)realloc(p,sizeof(morph_point8)*total);           
321              morph_point8 *mod=((morph_point8 *)p)+total-1;
322              mod->x1=shortest->x1;
323              mod->y1=shortest->y1;
324              mod->start_color=shortest->start_color;             
325
326              mod->x2=shortest_end_x;
327              mod->y2=shortest_end_y;             
328              mod->end_color=end_map[shortest_end_x+shortest_end_y*w];           
329            }           
330            else
331            {         
332              skipped++;
333              printf("skiped so far : %d (frame %d)\n",skipped,frame_on);
334            }
335           
336
337          }     
338        }
339      }
340    } 
341  }
342 
343  jfree(middle_map);
344  jfree(end_map);
345 
346}
347
348
349
350jmorph::jmorph(spec_entry *e, bFILE *fp)
351{
352  int i;
353  fp->seek(e->offset,0);
354  fp->read(&total,4); 
355  total=long_to_local(total);
356  if (e->type==SPEC_MORPH_POINTS_8 || e->type==SPEC_PATCHED_MORPH)
357  {
358    p=(void *)jmalloc(sizeof(morph_point8)*total,"morph8::point array");
359    fp->read(p,sizeof(morph_point8)*total);
360    small=1;
361  }
362  else
363  {
364    p=(void *)jmalloc(sizeof(morph_point16)*total,"morph16::point array");
365
366    for (i=0;i<total;i++)
367    {
368      ((morph_point16 *)p+i)->x1=fp->read_uint16();
369      ((morph_point16 *)p+i)->y1=fp->read_uint16();
370      ((morph_point16 *)p+i)->x2=fp->read_uint16();
371      ((morph_point16 *)p+i)->y2=fp->read_uint16();
372      fp->read( &((morph_point16 *)p+i)->start_color,1);
373      fp->read( &((morph_point16 *)p+i)->end_color,1);
374    }
375
376    small=0;
377  }
378  w[0]=fp->read_uint16();
379  h[0]=fp->read_uint16(); 
380  w[1]=fp->read_uint16();
381  h[1]=fp->read_uint16();
382}
383
384void jmorph::show_frame(image *screen, int x, int y,
385                      int frames, int frame_on, color_filter *fli, palette *pal)
386{
387  int pixelx,pixely,i;
388  short cx1,cy1,cx2,cy2;
389  unsigned char r,g,b;
390  unsigned char *scolor,*ecolor,*addr=(unsigned char *)pal->addr();
391  screen->get_clip(cx1,cy1,cx2,cy2);
392
393  if (small)
394  {
395    morph_point8 *p_on=(morph_point8 *)p;
396    for (i=0;i<total;i++,p_on++)
397    {
398      pixelx=(long)((int)p_on->x2-(int)p_on->x1)*(long)frame_on/(long)frames+p_on->x1+x;
399      pixely=(long)((int)p_on->y2-(int)p_on->y1)*(long)frame_on/(long)frames+p_on->y1+y;
400      if (pixelx>=cx1 && pixely>=cy1 && pixelx<=cx2 && pixely<=cy2)
401      {
402        scolor=addr+((int)p_on->start_color)*3;
403        ecolor=addr+((int)p_on->end_color)*3;
404        r=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++;
405        g=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++;
406        b=((int)(*ecolor)-(int)(*scolor))*frame_on/frames+*scolor;
407        *(screen->scan_line(pixely)+pixelx)=fli->lookup_color(r>>3,g>>3,b>>3);
408      }
409    }
410  }
411  else
412  {
413    morph_point16 *p_on=(morph_point16 *)p;
414    for (i=0;i<total;i++,p_on++)
415    {
416      pixelx=(long)((int)p_on->x2-(int)p_on->x1)*(long)frame_on/(long)frames+p_on->x1+x;
417      pixely=(long)((int)p_on->y2-(int)p_on->y1)*(long)frame_on/(long)frames+p_on->y1+y;
418      if (pixelx>=cx1 && pixely>=cy1 && pixelx<=cx2 && pixely<=cy2)
419      {
420        scolor=addr+((int)p_on->start_color)*3;
421        ecolor=addr+((int)p_on->end_color)*3;
422        r=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++;
423        g=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++;
424        b=((int)(*ecolor)-(int)(*scolor))*frame_on/frames+*scolor;
425        *(screen->scan_line(pixely)+pixelx)=fli->lookup_color(r>>3,g>>3,b>>3);
426      }
427    }
428  }
429
430
431void jmorph::show_24frame(unsigned char *screen, int width, int height,
432                  int x, int y, int frames, int frame_on, palette *pal)
433{
434    int pixelx,pixely,i;
435  unsigned char *scolor,*ecolor,*addr=(unsigned char *)pal->addr(),*pix;
436 
437  if (small)
438  {
439    morph_point8 *p_on=(morph_point8 *)p;
440    for (i=0;i<total;i++,p_on++)
441    {
442      pixelx=(long)((int)p_on->x2-(int)p_on->x1)*(long)frame_on/(long)frames+p_on->x1+x;
443      pixely=(long)((int)p_on->y2-(int)p_on->y1)*(long)frame_on/(long)frames+p_on->y1+y;
444
445      if (pixelx>=0 && pixely>=0 && pixelx<width && pixely<height)
446      {
447        scolor=addr+((int)p_on->start_color)*3;
448        ecolor=addr+((int)p_on->end_color)*3;
449        pix=screen+pixelx*3+pixely*3*width;               
450        *pix=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++; pix++;     
451        *pix=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++; pix++;     
452        *pix=((int)(*ecolor)-(int)(*scolor))*frame_on/frames+*scolor;
453      }
454    }
455  }
456  else
457  {
458    morph_point16 *p_on=(morph_point16 *)p;
459    for (i=0;i<total;i++,p_on++)
460    {
461      pixelx=(long)((int)p_on->x2-(int)p_on->x1)*(long)frame_on/(long)frames+p_on->x1+x;
462      pixely=(long)((int)p_on->y2-(int)p_on->y1)*(long)frame_on/(long)frames+p_on->y1+y;
463
464      if (pixelx>=0 && pixely>=0 && pixelx<width && pixely<height)
465      {
466        scolor=addr+((int)p_on->start_color)*3;
467        ecolor=addr+((int)p_on->end_color)*3;
468        pix=screen+pixelx*3+pixely*3*width;               
469        *pix=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++; pix++;     
470        *pix=(((int)*(ecolor++))-((int)*scolor))*frame_on/frames+*scolor; scolor++; pix++;     
471        *pix=((int)(*ecolor)-(int)(*scolor))*frame_on/frames+*scolor;
472      }
473    }
474  }
475}
476
477
478jmorph::jmorph(image *i1, image *hint1, image *i2, image *hint2,
479                          int aneal_steps)
480{
481  w[0]=i1->width();
482  h[0]=i1->height(); 
483  w[1]=i2->width();
484  h[1]=i2->height(); 
485
486  struct { int start,end; } crange[256];
487  int hint_hist1[256],hint_hist2[256],x,y,total_hints=0,randp,cur_pix,
488      last=0,first=0,i,j,k,findx1,findy1,findx2,findy2,total1,total2,points;
489  unsigned char *sl,color;
490  void *plist;
491
492
493  CONDITION(i1->width()==hint1->width() && i1->height()==hint1->height() &&
494            i2->width()==hint2->width() && i2->height()==hint2->height(),
495            "Image sizes do not correspond with hint sizes");
496  if (i1->width()>255 || i2->width()>255 || i1->height()>255 || i2->height()>255)
497    small=0;
498  else small=1;
499
500  memset(hint_hist1,0,sizeof(hint_hist1));
501  memset(hint_hist2,0,sizeof(hint_hist2));
502  total=0;
503
504  // first found out how many hints we have to follow
505  for (y=0;y<hint1->height();y++)
506  { sl=hint1->scan_line(y);
507    for (x=hint1->width();x;x--,sl++)
508      if (*sl) hint_hist1[*sl]++;
509  }
510  for (y=0;y<hint2->height();y++)
511  { sl=hint2->scan_line(y);
512    for (x=hint2->width();x;x--,sl++)
513      if (*sl) hint_hist2[*sl]++;
514  }
515
516  // check the user and see if the mask match up
517  for (x=0;x<256;x++)
518  {
519    if ((hint_hist1[x]!=0 && hint_hist2[x]==0) ||
520        (hint_hist1[x]==0 && hint_hist2[x]!=0))
521    { printf("Color %d used for hinting is prent in one hint mask, but not the other\n",x);
522      exit(1);
523    } else if (hint_hist1[x])
524    {
525      if (!first) first=x;
526      total_hints++;
527      if (hint_hist1[x]>hint_hist2[x])
528        y=hint_hist1[x];
529      else
530        y=hint_hist2[x];
531      total+=y;
532      crange[x].start=last;
533      crange[x].end=last+y-1;
534      last+=y;
535    }
536  }
537  if (small)
538    plist=(void *)jmalloc(sizeof(morph_point8)*total,"morph8::point array");
539  else
540    plist=(void *)jmalloc(sizeof(morph_point16)*total,"morph16::point array");
541  CHECK(plist);
542  for (i=0,color=0;i<total_hints;i++)
543  {
544    color++; while (!hint_hist1[color]) color++;
545    findx1=findx2=-1; findy1=findy2=0;
546    total1=hint_hist1[color];
547    total2=hint_hist2[color];
548    if (total1>total2) points=total1; else points=total2;
549    for (j=0;j<points;j++)
550    {
551      if (total1)  // are there any more pixels left in this image?
552      { total1--;
553        do {
554          findx1++;
555          if (findx1>=hint1->width()) { findx1=0; findy1++; }
556        } while (hint1->pixel(findx1,findy1)!=color);
557      }
558      else
559      {
560        randp=rand()%j+crange[color].start;
561        if (small)
562        { findx1=((morph_point8 *)plist)[randp].x1;
563          findy1=((morph_point8 *)plist)[randp].y1;
564        } else
565        { findx1=((morph_point16 *)plist)[randp].x1;
566          findy1=((morph_point16 *)plist)[randp].y1;
567        }
568      }
569      if (total2)  // are there any more pixels left in this image?
570      {
571        total2--;
572        do {
573          findx2++;
574          if (findx2>=hint2->width()) { findx2=0; findy2++; }
575        } while (hint2->pixel(findx2,findy2)!=color);
576      }
577      else
578      {
579        randp=rand()%j+crange[color].start;
580        if (small)
581        { findx2=((morph_point8 *)plist)[randp].x2;
582          findy2=((morph_point8 *)plist)[randp].y2;
583        } else
584        { findx2=((morph_point16 *)plist)[randp].x2;
585          findy2=((morph_point16 *)plist)[randp].y2;
586        }
587      }
588      cur_pix=j+crange[color].start;
589      CHECK(cur_pix<total);
590
591      if (small)
592      {
593        ((morph_point8 *)plist)[cur_pix].x1=findx1; 
594        ((morph_point8 *)plist)[cur_pix].x2=findx2; 
595        ((morph_point8 *)plist)[cur_pix].y1=findy1; 
596        ((morph_point8 *)plist)[cur_pix].y2=findy2; 
597        ((morph_point8 *)plist)[cur_pix].start_color=i1->pixel(findx1,findy1);
598        ((morph_point8 *)plist)[cur_pix].end_color=i2->pixel(findx2,findy2);
599      }
600      else
601      {
602        ((morph_point16 *)plist)[cur_pix].x1=findx1; 
603        ((morph_point16 *)plist)[cur_pix].x2=findx2; 
604        ((morph_point16 *)plist)[cur_pix].y1=findy1; 
605        ((morph_point16 *)plist)[cur_pix].y2=findy2; 
606        ((morph_point16 *)plist)[cur_pix].start_color=i1->pixel(findx1,findy1);
607        ((morph_point16 *)plist)[cur_pix].end_color=i2->pixel(findx2,findy2);
608      }
609    }
610  }
611  int swap_point,distance,new_distance,hint_color,first_point,range,start;
612
613  int sx2,sy2,sec;
614  for (i=0;i<aneal_steps;i++)
615  {
616    for (j=0,first_point=0;j<total_hints;j++)
617    {
618      if (small)
619        hint_color=hint1->pixel(((morph_point8 *)plist)[first_point].x1,((morph_point8 *)plist)[first_point].y1);
620      else
621        hint_color=hint1->pixel(((morph_point16 *)plist)[first_point].x1,((morph_point16 *)plist)[first_point].y1);
622      start=crange[hint_color].start;
623      range=crange[hint_color].end-start+1;
624      for(k=crange[hint_color].start;k<=crange[hint_color].end;k++)
625      {
626        swap_point=rand()%range+start;
627        if (small)
628        {
629          morph_point8 *pk,*ps;
630          pk=(morph_point8 *)plist+k;
631          ps=(morph_point8 *)plist+swap_point;
632
633          distance=(pk->x2-pk->x1)*(pk->x2-pk->x1)+(pk->y2-pk->y1)*(pk->y2-pk->y1)+
634                   (ps->x2-ps->x1)*(ps->x2-ps->x1)+(ps->y2-ps->y1)*(ps->y2-ps->y1);
635          new_distance=(ps->x2-pk->x1)*(ps->x2-pk->x1)+(ps->y2-pk->y1)*(ps->y2-pk->y1)+
636                       (pk->x2-ps->x1)*(pk->x2-ps->x1)+(pk->y2-ps->y1)*(pk->y2-ps->y1);
637          if (new_distance<distance)
638          {
639            sx2=pk->x2;         sy2=pk->y2;
640            sec=pk->end_color;
641            pk->x2=ps->x2;      pk->y2=ps->y2;
642            pk->end_color=ps->end_color;
643            ps->x2=sx2;         ps->y2=sy2;
644            ps->end_color=sec;
645          }
646        } else
647        {
648          morph_point16 *pk,*ps;
649          pk=(morph_point16 *)plist+k;
650          ps=(morph_point16 *)plist+swap_point;
651
652          distance=(pk->x2-pk->x1)*(pk->x2-pk->x1)+(pk->y2-pk->y1)*(pk->y2-pk->y1)+
653                   (ps->x2-ps->x1)*(ps->x2-ps->x1)+(ps->y2-ps->y1)*(ps->y2-ps->y1);
654          new_distance=(ps->x2-pk->x1)*(ps->x2-pk->x1)+(ps->y2-pk->y1)*(ps->y2-pk->y1)+
655                       (pk->x2-ps->x1)*(pk->x2-ps->x1)+(pk->y2-ps->y1)*(pk->y2-ps->y1);
656          if (new_distance<distance)
657          {
658            sx2=pk->x2;         sy2=pk->y2;
659            sec=pk->end_color;
660            pk->x2=ps->x2;      pk->y2=ps->y2;
661            pk->end_color=ps->end_color;
662            ps->x2=sx2;         ps->y2=sy2;
663            ps->end_color=sec;
664          }
665        }
666      }
667      first_point=crange[hint_color].end+1;
668    }
669  }
670  p=plist;
671}
672
673int morph_width;
674
675int morph8_compare(const void *p1, const void *p2)
676{
677  int pos1=((morph_point8 *)p1)->x1+((morph_point8 *)p1)->y1*morph_width; 
678  int pos2=((morph_point8 *)p2)->x1+((morph_point8 *)p2)->y1*morph_width; 
679  if (pos1<pos2) return -1;
680  else if (pos1==pos2) return 0;
681  else return 1;
682 
683}
684
685
686int jmorph::write(bFILE *fp)
687{
688  int i;
689
690 
691  fp->write_uint32(total); 
692  if (small)
693  {
694
695    // if the points are put in order then they can be compressed easier
696    morph_width=max(bound_x2(0),bound_x2(1));      // global used by qsort compare routine
697    qsort(p,total,sizeof(morph_point8),morph8_compare); 
698   
699    fp->write(p,sizeof(morph_point8)*total);
700  } 
701  else
702  {
703    for (i=0;i<total;i++)
704    { fp->write_uint16(((morph_point16 *)p+i)->x1);
705      fp->write_uint16(((morph_point16 *)p+i)->y1);
706      fp->write_uint16(((morph_point16 *)p+i)->x2);
707      fp->write_uint16(((morph_point16 *)p+i)->y2);
708      fp->write( &((morph_point16 *)p+i)->start_color,1);
709      fp->write( &((morph_point16 *)p+i)->end_color,1);
710    }
711  }
712  fp->write_uint16(w[0]);
713  fp->write_uint16(h[0]);
714  fp->write_uint16(w[1]);
715  fp->write_uint16(h[1]);
716  return 1;
717}
718
719
720
721
722step_morph::step_morph(patched_morph *mor, palette *pal, int frame_direction, int face_direction)
723{
724  int i;
725  pm=mor;
726 
727  total=mor->total_points();     
728  points=(step_struct *)jmalloc(sizeof(step_struct)*total,"step_morph::points"); 
729 
730  dir=frame_direction;
731  face_dir=face_direction;
732 
733  if (dir>0)
734    frame_on=0;
735  else
736    frame_on=mor->patches-1;
737 
738  if (mor->small_morph())
739  {   
740      int x1,y1,x2,y2;
741
742   
743      if (frame_direction>0)
744      {     
745        morph_point8 *m8=mor->small_points();     
746       
747        for (i=0;i<total;i++,m8++)
748        {       
749          x1=(int)m8->x1;
750          x2=(int)m8->x2;
751
752          y1=(int)m8->y1;
753          y2=(int)m8->y2;
754
755          points[i].x=x1<<8;
756          points[i].y=y1<<8;       
757          points[i].dx=(x2-x1)<<5;
758          points[i].dy=(y2-y1)<<5;             
759         
760          unsigned char r1,g1,b1,r2,g2,b2;
761          pal->get(m8->start_color,r1,g1,b1);
762          pal->get(m8->end_color,r2,g2,b2);
763          points[i].r=r1<<8;
764          points[i].g=g1<<8;
765          points[i].b=b1<<8;
766
767          points[i].dr=(long)((int)r2-(int)r1)<<5;
768          points[i].dg=(long)((int)g2-(int)g1)<<5;
769          points[i].db=(long)((int)b2-(int)b1)<<5;                     
770        }
771      }   
772      else
773      {     
774        morph_point8 *m8=mor->small_points();     
775        for (i=0;i<total;i++,m8++)
776        {       
777          x1=(int)m8->x1;
778          x2=(int)m8->x2;
779
780          y1=(int)m8->y1;
781          y2=(int)m8->y2;
782
783          points[i].x=x2<<8;
784          points[i].y=y2<<8;       
785          points[i].dx=(x1-x2)<<5;
786          points[i].dy=(y1-y2)<<5;             
787
788          unsigned char r1,g1,b1,r2,g2,b2;
789          pal->get(m8->start_color,r2,g2,b2);
790          pal->get(m8->end_color,r1,g1,b1);
791          points[i].r=r1<<8;
792          points[i].g=g1<<8;
793          points[i].b=b1<<8;
794
795          points[i].dr=(long)((int)r2-(int)r1)<<5;
796          points[i].dg=(long)((int)g2-(int)g1)<<5;
797          points[i].db=(long)((int)b2-(int)b1)<<5;                     
798        }
799      }   
800  } 
801
802
803}
804
805void step_morph::show_frame(image *screen, int x, int y,  color_filter *fli)
806{
807  short x1,y1,x2,y2;
808  screen->get_clip(x1,y1,x2,y2);
809
810  int i,px,py,ww=max(pm->bound_x2(0),pm->bound_x2(1))-1;
811  step_struct *ss;
812
813  morph_patch *pat=pm->pats+frame_on; 
814  int j,tp=pat->patches;
815  unsigned char *sl=pat->patch_data;   
816
817  if (face_dir>0)
818  {   
819    for (i=0,ss=points;i<total;i++,ss++)
820    {
821      px=x+(ss->x>>(16-8));
822      py=y+(ss->y>>(16-8));
823      if (px>=x1 && px<=x2 && py>=y1 && py<=y2)
824        *(screen->scan_line(py)+px)=fli->lookup_color(ss->r>>(19-8),ss->g>>(19-8),ss->b>>(19-8));
825
826      ss->x+=ss->dx;
827      ss->y+=ss->dy;
828      ss->r+=ss->dr;
829      ss->g+=ss->dg;
830      ss->b+=ss->db;       
831    } 
832
833    for (j=0;j<tp;j++,sl++)
834    {
835      px=x+*(sl++);
836      py=y+*(sl++);
837      if (px>=x1 && px<=x2 && py>=y1 && py<=y2)
838        *(screen->scan_line(py)+px)=*sl;
839    }             
840  } else
841  {
842    for (i=0,ss=points;i<total;i++,ss++)
843    {
844      px=x+ww-(ss->x>>(16-8));
845      py=y+(ss->y>>(16-8));
846      if (px>=x1 && px<=x2 && py>=y1 && py<=y2)
847        *(screen->scan_line(py)+px)=fli->lookup_color(ss->r>>(19-8),ss->g>>(19-8),ss->b>>(19-8));
848
849      ss->x+=ss->dx;
850      ss->y+=ss->dy;
851      ss->r+=ss->dr;
852      ss->g+=ss->dg;
853      ss->b+=ss->db;       
854    } 
855
856    for (j=0;j<tp;j++,sl++)
857    {
858      px=x+(ww-(int)(*(sl++)));
859      py=y+*(sl++);
860      if (px>=x1 && px<=x2 && py>=y1 && py<=y2)
861        *(screen->scan_line(py)+px)=*sl;
862    }         
863  }
864 
865  frame_on+=dir;
866 
867}
868
869void step_morph::reverse_direction()
870{
871  step_struct *s=points;
872  int i;
873  for (i=0;i<total;i++,s++)
874  {
875    s->dx=-s->dx;
876    s->dy=-s->dy;
877    s->dr=-s->dr;
878    s->dg=-s->dg;
879    s->db=-s->db;   
880  }
881  dir=-dir;
882 
883}
884
885
886patched_morph::patched_morph(spec_entry *e, bFILE *fp) : jmorph(e,fp)
887{
888  int i;
889 
890  patches=fp->read_uint16();
891  pats=(morph_patch *)jmalloc(sizeof(morph_patch)*patches,"patched_morph::points");
892 
893  for (i=0;i<patches;i++)
894  {
895    pats[i].patches=fp->read_uint16();
896    if (pats[i].patches)
897    {     
898      pats[i].patch_data=(unsigned char *)jmalloc(3*pats[i].patches,"patched_morph::patch_data");
899      fp->read(pats[i].patch_data,3*pats[i].patches);     
900    }
901    else
902      pats[i].patch_data=NULL;
903  }   
904}
905
906
Note: See TracBrowser for help on using the repository browser.