render_do.c.svn-base

A Flash Player with ActionScript support. Write in C and C++. It have two part, one is Player and an

#include <stdio.h>
#include <glib.h>
#include "instance.h"
#include "player_pub.h"
#include "swf_file_pub.h"
#include "static_text_ins.h"
#include "xwin_pub.h"
#include "movie_clips_ins.h"
#include "render_pub.h"
#include <strings.h>
#include <inttypes.h>
#include <shape_def.h>
#include <render_shape.h>
#include <render_rend.h>
#include <static_text_def.h>
#include <matrix.h>
#include <morphing_ins.h>
#include <cxform.h>
#include <render_mask.h>
extern int hb;
#include <stdlib.h>
#include <assert.h>
#include "config.h"
#if WITH_DMALLOC
#include <dmalloc.h>
#endif
extern player_t 	*player_p;
extern struct GraphicDevice gd;
extern struct ShapeDef  shapedef;
unsigned int gmaskflag=0;
unsigned int gmaskedflag=0;
struct savearea *currentpic=0;
struct savearea *storepic=0;
struct RECT idrect;
int save=0;
void docopy(GraphicDevice *gd,GNode* node_p) {
    instance_t  *data_p = (instance_t*)(node_p->data);
    long x,y;
    long dx,dy;
    unsigned long c1,c2,p1,p2;
    unsigned long *line;
    struct spin tmp;
    unsigned char *line1;

    if(!data_p->pic_p)
        return;
    if(gmaskflag)
        return ;
    if(gmaskedflag) {

        struct MaskEntry *currentmaskentry;
        unsigned char *currentmaskpointer;
        currentmaskentry=player_p->_level0_p->mask_stack_p;
        currentmaskpointer=currentmaskentry->maskpointer;
        {
            dx=data_p->pic_p->bound.Xmax-data_p->pic_p->bound.Xmin;
            dy=data_p->pic_p->bound.Ymax-data_p->pic_p->bound.Ymin;

            for(y=idrect.Ymin;y<idrect.Ymin+dy;y++) {
                if(y<0)
                    continue;
                if(y>(gd->viewPort.Ymax))
                    continue;

                //printf("y1=%ld y2=%ld\n",idrect.Ymin,idrect.Ymin+dy);
                if(currentmaskpointer)
                    line1=(unsigned char*)( (unsigned char*)currentmaskpointer+(gd->bpl*y)/2+idrect.Xmin);
                line=(unsigned long *)((unsigned char*)(gd->canvasBuffer) +gd->bpl*y*2+(idrect.Xmin*4));
                tmp=data_p->pic_p->sp[y-idrect.Ymin];
                //printf("y is %ld\n",y);
                //printf("tmp  idrect xmin is %ld ymin is %ld xmax is %ld ymax is %ld\n",idrect.Xmin,idrect.Ymin,idrect.Xmax,idrect.Ymax);
                //mix_line(line,&(data_p->pic_p->pp[(dx)*(y-idrect.Ymin)]),dx);

                mix_line(&(data_p->pic_p->pp[(dx)*(y-idrect.Ymin)]),line,dx);

                /*if(((tmp.x2-tmp.x1+1)&(0x0001))==0)
                 
                {
                //printf("x1=%ld x2 is %ld\n",tmp.x1,tmp.x2);
                for(x=tmp.x1;x<=tmp.x2;x=x+2)
                {
                 
                struct tb  tb1;
                if((idrect.Xmin+x)<0) continue;
                if((idrect.Xmin+x)>(gd->viewPort.Xmax)) continue;
                 
                 
                p1=data_p->pic_p->pp[(dx)*(y-idrect.Ymin)+x];
                 
                c1=line[x];
                 
                p2=data_p->pic_p->pp[(dx)*(y-idrect.Ymin)+x+1];
                 
                c2=line[x+1];
                //printf("tb1 point is %p\n",&tb1);
                mix_alpha(c1,c2,p1,p2,&tb1);
                if(line1[x]==1)
                line[x]=tb1.p1;
                if(line1[x+1]==1)
                line[x+1]=tb1.p2;
                }
                 
                }
                else
                {
                //printf("x1=%ld x2 is %ld\n",tmp.x1,tmp.x2);
                for(x=tmp.x1;x<=(tmp.x2-1);x=x+2)
                {
                 
                struct tb  tb1;
                if((idrect.Xmin+x)<0) continue;
                if((idrect.Xmin+x)>(gd->viewPort.Xmax)) continue;
                 
                 
                p1=data_p->pic_p->pp[(dx)*(y-idrect.Ymin)+x];
                 
                c1=line[x];
                p2=data_p->pic_p->pp[(dx)*(y-idrect.Ymin)+x+1];
                c2=line[x+1];
                 
                //assert(c1==c2);
                //printf("tb1 point is %p\n",&tb1);
                mix_alpha(c1,c2,p1,p2,&tb1);
                if(line1[x]==1)
                line[x]=tb1.p1;
                if(line1[x+1]==1)
                line[x+1]=tb1.p2;
                 
                }
                struct tb  tb2;
                 
                p1=data_p->pic_p->pp[(dx)*(y-idrect.Ymin)+x-1];
                 
                c1=line[x-1];
                 
                p2=1;
                c2=1;
                 
                mix_alpha(c1,c2,p1,p2,&tb2);
                if(line1[x]==1)
                line[x]=tb2.p1;
                }*/
            }
        }
        printf("do masked\n");
    } else {
        dx=data_p->pic_p->bound.Xmax-data_p->pic_p->bound.Xmin;
        dy=data_p->pic_p->bound.Ymax-data_p->pic_p->bound.Ymin;
        //printf("pp is %p\n",data_p->pic_p->pp);
        for(y=idrect.Ymin;y<idrect.Ymin+dy;y++) {
            if(y<0)
                continue;
            if(y>(gd->viewPort.Ymax))
                continue;
            //printf("y1=%ld y2=%ld\n",idrect.Ymin,idrect.Ymin+dy);
            line=(unsigned long *)((unsigned char*)(gd->canvasBuffer) +gd->bpl*y*2+(idrect.Xmin*4));
            tmp=data_p->pic_p->sp[y-idrect.Ymin];
            //printf("y is %ld\n",y);
            //printf("tmp  idrect xmin is %ld ymin is %ld xmax is %ld ymax is %ld\n",idrect.Xmin,idrect.Ymin,idrect.Xmax,idrect.Ymax);
            //mix_line(line,&(data_p->pic_p->pp[(dx)*(y-idrect.Ymin)]),dx);
            //printf("y is %ld\n",y);

            mix_line(&(data_p->pic_p->pp[(dx)*(y-idrect.Ymin)]),line,dx);

            //printf("line[10] is %ld\n",line[10]);
            /*if(((tmp.x2-tmp.x1+1)&(0x0001))==0)
             
            {
            //printf("x1=%ld x2 is %ld\n",tmp.x1,tmp.x2);
            for(x=tmp.x1;x<=tmp.x2;x=x+2)
            {
             
            struct tb  tb1;
            if((idrect.Xmin+x)<0) continue;
            if((idrect.Xmin+x)>(gd->viewPort.Xmax)) continue;
             
             
            p1=data_p->pic_p->pp[(dx)*(y-idrect.Ymin)+x];
            //p1=(p1&0x00ffffff)|0xff000000;
            c1=line[x];
             
            p2=data_p->pic_p->pp[(dx)*(y-idrect.Ymin)+x+1];
            //p2=(p2&0x00ffffff)|0xff000000;
            c2=line[x+1];
            //printf("tb1 point is %p\n",&tb1);
            mix_alpha(c1,c2,p1,p2,&tb1);
            line[x]=tb1.p1;
            line[x+1]=tb1.p2;
            }
             
            }
            else
            {
             
            //printf("x1=%ld x2 is %ld\n",tmp.x1,tmp.x2);
            for(x=tmp.x1;x<=(tmp.x2-1);x=x+2)
            {
             
            struct tb  tb1;
            if((idrect.Xmin+x)<0) continue;
            if((idrect.Xmin+x)>(gd->viewPort.Xmax)) continue;
             
             
            p1=data_p->pic_p->pp[(dx)*(y-idrect.Ymin)+x];
             
            c1=line[x];
            p2=data_p->pic_p->pp[(dx)*(y-idrect.Ymin)+x+1];
            c2=line[x+1];
             
            //assert(c1==c2);
            //printf("tb1 point is %p\n",&tb1);
            mix_alpha(c1,c2,p1,p2,&tb1);
             
            line[x]=tb1.p1;
            line[x+1]=tb1.p2;
             
            }
            struct tb  tb2;
             
            p1=data_p->pic_p->pp[(dx)*(y-idrect.Ymin)+x-1];
             
            c1=line[x-1];
             
            p2=1;
            c2=1;
             
            mix_alpha(c1,c2,p1,p2,&tb2);
            line[x]=tb2.p1;
            }*/
        }
        //printf("over do copy\n");
    }
}
void render_draw_node(GNode* node_p,gpointer render_p) {
    instance_t  *data_p = (instance_t*)(node_p->data);
    define_t  	*def_p  = (define_t*)data_p->define_p;
    swf_file_t	*swf_p = data_p->swf_p;
    int i;
    //if(def_p->CharacterID==1) data_p->pic_dirty=1;
    //||def_p->CharacterID==2)//||def_p->CharacterID==4)//||def_p->CharacterID==5)
    //if(def_p->CharacterID==1)

    {

        struct CxFormWithAlpha cxf,*cxf1,*cxf2;
        GNode *nodetmp=0;
        instance_t  *tmpdata;
        int cxformflag=1;
        struct cxforms {
            struct cxforms *priv;
            struct CxFormWithAlpha *cx;
            struct cxforms *next;
        }
        *tmpcxformp,*tmpcxformp1,*tmpcx,*cxformdel;
        struct CxFormWithAlpha  cxformmiddle;
        // if(def_p->CharacterID!=1||def_p->CharacterID!=2||def_p->CharacterID!=4||def_p->CharacterID!=5) return;
        tmpcxformp=0;
        tmpcxformp1=0;
        tmpcx=0;
        cxformdel=0;
        tmpcxformp=malloc(sizeof(struct cxforms));
        tmpcxformp->cx=&(data_p->cxform);
        tmpcxformp->next=0;
        tmpcxformp->priv=0;
        if(node_p->parent)
            nodetmp=node_p->parent;
        while(nodetmp) {
            tmpcx=malloc(sizeof(struct cxforms));
            tmpdata= (instance_t*)(nodetmp->data);
            tmpcx->cx=&(tmpdata->cxform);
            tmpcx->next=tmpcxformp;
            tmpcxformp->priv=tmpcx;
            tmpcxformp=tmpcx;
            nodetmp=nodetmp->parent;
            //	printf("to there\n");
        };

        cxf.RedMultTerm=1;
        cxf.GreenMultTerm=1;
        cxf.BlueMultTerm=1;
        cxf.AlphaMultTerm=1;
        cxf.RedAddTerm=0;
        cxf.GreenAddTerm=0;
        cxf.BlueAddTerm=0;
        cxf.AlphaAddTerm=0;
        cxformmiddle=cxf;
        tmpcxformp1=tmpcxformp;
        while(tmpcxformp) {
            cxf.RedMultTerm = cxf.RedMultTerm * tmpcxformp->cx->RedMultTerm;
            cxf.GreenMultTerm = cxf.GreenMultTerm * tmpcxformp->cx->GreenMultTerm;
            cxf.BlueMultTerm = cxf.BlueMultTerm * tmpcxformp->cx->BlueMultTerm;
            cxf.AlphaMultTerm = cxf.AlphaMultTerm * tmpcxformp->cx->AlphaMultTerm;

            cxf.RedAddTerm = (long)
                             (cxf.RedMultTerm * tmpcxformp->cx->RedAddTerm + cxf.RedAddTerm);
            cxf.GreenAddTerm = (long)(cxf.GreenMultTerm * tmpcxformp->cx->GreenAddTerm + cxf.GreenAddTerm);
            cxf.BlueAddTerm = (long)(cxf.BlueMultTerm * tmpcxformp->cx->BlueAddTerm + cxf.BlueAddTerm);
            cxf.AlphaAddTerm = (long)(cxf.AlphaMultTerm * tmpcxformp->cx->AlphaAddTerm + cxf.AlphaAddTerm);
            tmpcxformp=tmpcxformp->next;
        }
        if(cxf.RedMultTerm==1&&cxf.GreenMultTerm==1&&cxf.BlueMultTerm==1&&cxf.AlphaMultTerm==1)
            if(cxf.RedAddTerm==0&&cxf.GreenAddTerm==0&&cxf.BlueAddTerm==0&&cxf.AlphaAddTerm==0)
                cxformflag=0;

        while(tmpcxformp1) {
            cxformdel=tmpcxformp1->next;
            free(tmpcxformp1);
            tmpcxformp1=cxformdel;
        }

        if(hb==1&&data_p->clip_depth==0) {

            maskhb(swf_p);
            hb=0;

        }
        if(data_p->clip_depth!=0||((node_p->parent)&&((instance_t*)(node_p->parent->data))->clip_depth!=0)) {
            //printf("to mask\n");
            gmaskflag=1;
            gmaskedflag=0;
        } else {
            if(swf_p->mask_stack_p) {
                //printf("to masked\n");
                gmaskflag=0;
                gmaskedflag=1;
            } else {
                gmaskflag=0;
                gmaskedflag=0;
            }

        }