render.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 "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 <dynamic_text_ins.h>
#include <matrix.h>
#include <morphing_ins.h>
#include <cxform.h>
#include <assert.h>
#include "render_mask.h"
#include "button_ins.h"
#if WITH_DMALLOC
#include <dmalloc.h>
#endif

extern player_t 	*player_p;
extern struct GraphicDevice gd;
extern struct ShapeDef  shapedef;
gboolean render_print_node(GNode* node_p,gpointer no_use) {
    instance_t  *data_p = (instance_t*)(node_p->data);
    define_t  	*def_p  = (define_t*)data_p->define_p;
    int i;

    for (i=0;i<g_node_depth(node_p);i++) {
        printf("\t");
    };

    printf("%3d", data_p->depth);

    if (data_p->dirty) {
        printf("+");
    } else {
        printf("-");
    };
    if (data_p->pic_dirty) {
        printf("*");
    } else {
        printf(" ");
    };
    if (data_p->visible) {
        printf("v ");
    } else {
        printf("  ");
    };

    printf("id%3d ",def_p->CharacterID);
    switch (data_p->ins_type) {
    case INS_MC:
        printf("MC  ");
        break;
    case INS_BTN:
        printf("BTN ");
        break;
    case INS_STX:
        printf("STX ");
        break;
    case INS_DTX:
        printf("DTX ");
        break;
    case INS_MRH:
        printf("MRH ");
        break;
    case INS_SHP:
        printf("SHP ");
        break;
    };

    if (data_p->clip_depth > 0) {
        printf("M ");
    };

    printf("%5ld %5ld %5ld %5ld ",data_p->boundary.Xmin
           ,data_p->boundary.Xmax
           ,data_p->boundary.Ymin
           ,data_p->boundary.Ymax);

    if (data_p->name_p)
        printf("nm %s ",data_p->name_p);

    if ((data_p->ins_type == INS_DTX) && (((dtx_ins_t*)data_p)->var_name_p))
        printf("vn %s ",((dtx_ins_t*)data_p)->var_name_p);

    if (data_p->ins_type == INS_MC) {
        printf("lfm %d nfm %d ",((mc_ins_t*)data_p)->last_frame,((mc_ins_t*)data_p)->next_frame);
        switch (((mc_ins_t*)data_p)->state) {
        case MC_TO_STOP:
            printf("ToStop ");
            break;
        case MC_STOP:
            printf("Stop ");
            break;
        case MC_PLAY:
            printf("Play ");
            break;
        };
    };

    if (data_p->ins_type == INS_BTN) {
        printf("ls ");
        switch (((btn_ins_t*)data_p)->last_state) {
        case BtnStateOverDown:
            printf("OverDown ");
            break;
        case BtnStateOutDown:
            printf("OutDown ");
            break;
        case BtnStateOverUp:
            printf("OverUp ");
            break;
        case BtnStateOutUp:
            printf("OutUp ");
            break;
        default:
            printf("Unknown ");
            break;
        };
        printf("cs ");
        switch (((btn_ins_t*)data_p)->current_state) {
        case BtnStateOverDown:
            printf("OverDown ");
            break;
        case BtnStateOutDown:
            printf("OutDown ");
            break;
        case BtnStateOverUp:
            printf("OverUp ");
            break;
        case BtnStateOutUp:
            printf("OutUp ");
            break;
        default:
            printf("Unknown ");
            break;
        };

        printf("ha %5ld %5ld %5ld %5ld ",((btn_ins_t*)data_p)->hit_area.Xmin
               ,((btn_ins_t*)data_p)->hit_area.Xmax
               ,((btn_ins_t*)data_p)->hit_area.Ymin
               ,((btn_ins_t*)data_p)->hit_area.Ymax);
    };
    printf("\n");
    return FALSE;
};

void render_print_tree(GNode *node_p) {
    //    printf("frame %d --- \n",((mc_ins_t*)(node_p->data))->last_frame);
    g_node_traverse(node_p,G_PRE_ORDER,G_TRAVERSE_ALL,-1,render_print_node,0);
};

struct mask_stack_data {
    UI16 mask_begin;		// 遮罩开始层
    UI16 be_masked_begin;	// 被遮罩开始层
    UI16 be_masked_end;		// 被遮罩结束层
};

void render_draw_ins(GNode* node_p) {
    instance_t  *data_p = (instance_t*)(node_p->data);
    swf_file_t  *swf_p  = data_p->swf_p;
    GNode 	*child;
    GSList	*mask_stack = NULL;		// 使用堆栈管理同层兄弟中有嵌套关系的遮罩
    struct mask_stack_data	*mp;

    switch (data_p->ins_type) {
    case INS_MC:
    case INS_BTN:
        //        render_draw_box(render_p,&data_p->boundary,3);
        break;
    case INS_STX:
    case INS_DTX:
    case INS_MRH:
    case INS_SHP:
        if ((data_p->dirty) && (data_p->visible)) {
            //           render_draw_box(render_p,&data_p->boundary,2);
            render_draw_node(node_p,NULL);
        } else {
            //            render_draw_box(render_p,&data_p->boundary,1);
        }
        break;
    };
//    printf("node %s change dirty beclean\n",data_p->name_p);
    data_p->dirty = FALSE;		// 节点画完后将其标为 _NOT_ dirty

    child = node_p->children;
    while (child) {
        register GNode *current;
        instance_t     *cur_data_p = NULL;
        current = child;
        cur_data_p = (instance_t*)current->data;
        child = current->next;

        // 如果已跑到 mask 开始处的桢,通知渲染部分 mask 开始
        if (mask_stack
                && ((struct mask_stack_data*)mask_stack->data)->be_masked_begin
                && (cur_data_p->depth >= ((struct mask_stack_data*)mask_stack->data)->be_masked_begin)) {
            ((struct mask_stack_data*)mask_stack->data)->be_masked_begin = 0;
            printf("be_masked_begin\n");
            //           render_be_masked_begin(current);
        };
        // 如果已跑到 mask 结束处的桢,通知渲染部分 mask 结束
        if (mask_stack && (cur_data_p->depth >= ((struct mask_stack_data*)mask_stack->data)->be_masked_end)) {
            render_mask_leave(current);
            free(mask_stack->data);		// 从栈上弹出一节点.
            mask_stack = g_slist_delete_link(mask_stack,mask_stack);
            printf("------- leave mask \n");
        };
        // 如果 clip_depth > 0 标记此层 mask 开始.取被遮罩的开始和结束
        if (cur_data_p->clip_depth > 0) {
            mp = g_new0(struct mask_stack_data,1);
            mp->mask_begin = cur_data_p->depth;
            mp->be_masked_begin = mp->mask_begin + 1;
            mp->be_masked_end = cur_data_p->clip_depth;
            mask_stack = g_slist_prepend(mask_stack,mp);
            printf("mask begin %d  be masked begin %d  be masked end %d \n",cur_data_p->depth,mp->be_masked_begin,mp->be_masked_end);
        };
        // 非 MC 型的遮罩. 通知遮罩开始.
        if ((cur_data_p->ins_type!=INS_MC) && (cur_data_p->clip_depth > 0)) {
            printf("------- enter mask1 \n");
            render_mask_enter(current);
        };
        // MC 型遮罩. MC 的头一个 child 发通知.
        if ((cur_data_p->ins_type!=INS_MC)
                && ((current->parent) && ((instance_t*)(current->parent->data))->clip_depth > 0)
                && (current == (current->parent)->children)
           ) {
            printf("------- enter mask2 \n");
            render_mask_enter(current);
        };
        render_draw_ins(current);
    };
    while (mask_stack) {
        if (((struct mask_stack_data*)mask_stack->data)->be_masked_begin) {
            printf("be_masked_begin\n");
            // render_be_masked_begin(node_p);
        };
        render_mask_leave(node_p);
        printf("------- leave mask \n");
        free(mask_stack->data);		// 从栈上弹出一节点.
        mask_stack = g_slist_delete_link(mask_stack,mask_stack);
    };
};

void render_do_render(render_t *render_p) {
    player_t	*player_p 	= render_p->player_p;
    swf_file_t	*swf_p 		= player_p->_level0_p;
    GNode	*node_p 	= swf_p->_root_p;

    render_draw_ins(node_p);
    //    g_node_traverse(node_p,G_PRE_ORDER,G_TRAVERSE_ALL,-1,render_draw_ins,render_p);
};

render_t *render_new(player_t *player_p) {
    render_t	*render_p 		= g_new0(render_t,1);

    render_p->player_p = player_p;
    return render_p;
};

void render_destory(render_t *render_p) {
    free(render_p);
};

void render_draw_box(struct RECT *rect_p,int type) {
    //  player_t	*player_p 	= render_p->player_p;
    swf_file_t	*swf_p 		= player_p->_level0_p;
    xwin_t	*xwin_p		= player_p->xwin_p;
    FlashDisplay	*fd_p	= &xwin_p->fd;

    uint8_t	*buf;
    int		x,y;
    int		Xmin,Xmax,Ymin,Ymax;
    //    uint16_t	color = (color.Red >> 3)<<11 | (color.Green>>2)<<5 | (color.Blue>>3);
    uint16_t	color;

    switch (type) {
    case 1:
        color = (0x80 >> 3)<<11 | (0x80 >> 2)<<5 | (0x80 >>3);
        break;
    case 2:
        color = (0x80 >> 3)<<11 | (0x0 >> 2)<<5 | (0x0 >>3);
        break;
    case 3:
        color = (0x0 >> 3)<<11 | (0x80 >> 2)<<5 | (0x0 >>3);
        break;
    case 4:
        color = (0x0 >> 3)<<11 | (0x0 >> 2)<<5 | (0x80 >>3);
        break;
    };
    if (rect_p == 0)
        return;
    if (rect_p->Ymin > swf_p->frame_size.Ymax)
        return;
    if (rect_p->Xmin > swf_p->frame_size.Xmax)
        return;
    if (rect_p->Xmax < swf_p->frame_size.Xmin)
        return;
    if (rect_p->Ymax < swf_p->frame_size.Ymin)
        return;

    buf = fd_p->pixels;

    Xmin = rect_p->Xmin;
    Xmax = rect_p->Xmax;
    Ymin = rect_p->Ymin;
    Ymax = rect_p->Ymax;

    if (rect_p->Xmin < swf_p->frame_size.Xmin) {
        Xmin = swf_p->frame_size.Xmin;
    };
    if (rect_p->Xmax > swf_p->frame_size.Xmax) {
        Xmax = swf_p->frame_size.Xmax;
    };
    if (rect_p->Ymin < swf_p->frame_size.Ymin) {
        Ymin = swf_p->frame_size.Ymin;
    };
    if (rect_p->Ymax > swf_p->frame_size.Ymax) {
        Ymax = swf_p->frame_size.Ymax;
    };

    Xmin = Xmin/xwin_p->twips_per_pixel;
    Xmax = Xmax/xwin_p->twips_per_pixel-1;
    Ymin = Ymin/xwin_p->twips_per_pixel;
    Ymax = Ymax/xwin_p->twips_per_pixel-1;

    for ( x = Xmin ; x < Xmax; x++) {
        y = Ymin;
        *(uint16_t*)(buf+y*fd_p->bpl+x*fd_p->bpp) = color;
        y = Ymax;
        *(uint16_t*)(buf+y*fd_p->bpl+x*fd_p->bpp) = color;
    };
    for ( y = Ymin ; y < Ymax; y++) {
        x = Xmin;
        *(uint16_t*)(buf+y*fd_p->bpl+x*fd_p->bpp) = color;
        x = Xmax;
        *(uint16_t*)(buf+y*fd_p->bpl+x*fd_p->bpp) = color;
    };
};

void render_clear_box(render_t *render_p) {
    player_t	*player_p 	= render_p->player_p;
    xwin_t	*xwin_p		= player_p->xwin_p;
    FlashDisplay	*fd_p	= &xwin_p->fd;

    uint8_t	*buf;
    static int i=1;
    if(player_p->_level0_p->changed_p->dirty_area.Xmin==LONG_MAX&&player_p->_level0_p->changed_p->dirty_area.Ymin == LONG_MAX&&\
            player_p->_level0_p->changed_p->dirty_area.Xmax == LONG_MIN&&player_p->_level0_p->changed_p->dirty_area.Ymax == LONG_MIN) {

        return 0;
    }
    updateClippingRegion(&gd,&player_p->_level0_p->changed_p->dirty_area);
    if(i==1)
        clearCanvas16(&gd,1);
    else
        clearCanvas16(&gd,0);
    i=i+1;
    /* buf = fd_p->pixels;

     bzero(buf,fd_p->width*fd_p->height*2);
        bzero(fd_p->pixels,1000);*/

};