gpsi_uti.c

操作系统SunOS 4.1.3版本的源码

	    case CTX_DONT_CLEAR:
		dont_clear_ctx = 1;
		break;

	    case CTX_SET_FB_NUM:
		fb_num = (unsigned char)va_arg(ap, int);
		break;

	    case CTX_SET_FB_PLANES:
		fb_planes = (unsigned int)va_arg(ap, int);
		break;

	    case CTX_SET_ROP:
		rop = (short)va_arg(ap, int);
		break;

	    case CTX_SET_CLIP_LIST:
		ncliprect = (short)va_arg(ap, int);
		cliprects = va_arg(ap, Rect *);
		break;

	    case CTX_SET_CLIP_PLANES:
		clip_planes = (unsigned char)va_arg(ap, int);
		break;

	    case CTX_SET_LINE_WIDTH:
		line_width = (short)va_arg(ap, int);
		line_width_opt = (short)va_arg(ap, int);
		break;

	    case CTX_SET_LINE_TEX:
		pr_tex_ptr = va_arg(ap, short *);
		pr_tex_offset = (short)va_arg(ap, int);
		pr_tex_options = (short)va_arg(ap, int);
		break;

	    case CTX_SET_VWP_3D:
		xscale = (float)va_arg(ap, double);
		xoffs = (float)va_arg(ap, double);
		yscale = (float)va_arg(ap, double);
		yoffs = (float)va_arg(ap, double);
		zscale = (float)va_arg(ap, double);
		zoffs = (float)va_arg(ap, double);
		break;

	    case CTX_SET_MAT_NUM:
		use_mat_num = (unsigned char)va_arg(ap, int);
		break;

	    case CTX_SET_MAT_3D:
		set_mat_num = (unsigned char)va_arg(ap, int);
		matrix_3d = va_arg(ap, Matrix_3D *);
		break;

	    case CTX_SET_ZBUF:
		zbuf_depth = (short)va_arg(ap, int);
		zbuf_x = (short)va_arg(ap, int); 
		zbuf_y = (short)va_arg(ap, int); 
		zbuf_width = (short)va_arg(ap, int); 
		zbuf_height = (short)va_arg(ap, int); 
	        break;

	    case CTX_SET_DEPTH_CUE:
		depth_cue = (unsigned char)va_arg(ap, int);
		break;

	    case CTX_SET_DEPTH_CUE_COLORS:
		depth_cue_front_color = va_arg(ap, unsigned int);
		depth_cue_back_color = va_arg(ap, unsigned int);
		break;

	    case CTX_SET_HIDDEN_SURF:
		hidden_surf = (unsigned char)va_arg(ap, int);
		break;

	    case CTX_SET_RGB_COLOR:
		rgb_color = va_arg(ap, unsigned int);
		rgb_color_red = (float)(rgb_color & 0xff) / 255.0 ;
		rgb_color_green = (float)((rgb_color & 0xff00) >> 8) / 255.0 ;
		rgb_color_blue = (float)((rgb_color & 0xff0000) >>16) / 255.0 ;
		break;

	    default:
		va_end(pa);
		TRACE_OUT
		return(errmsg_list[25]);
	}
    }
    va_end(pa);
    TRACE_OUT
    return (ctx_post());
}

/**********************************************************************/
ctx_default()
/**********************************************************************/
/* Sets common context attributes to the default values */
{
    
    static short zero=0;
    static Matrix_3D id_3d = {
				    1.0, 0.0, 0.0, 0.0,
				    0.0, 1.0, 0.0, 0.0,
				    0.0, 0.0, 1.0, 0.0,
				    0.0, 0.0, 0.0, 1.0,
			     };

    func_name = "ctx_default";
    TRACE_IN

    dont_clear_ctx = 0;
    fb_num = gp1_d(GP_pr)->cg2_index;
    fb_planes = 0xffffffff;
    rop = PIX_SRC;
    ncliprect = 1;
    cliprects = &GP_r;
    clip_planes = 0x0;
    line_width = 1;
    line_width_opt = 0;
    pr_tex_ptr = &zero;
    pr_tex_offset = 0;
    pr_tex_options = 0;
    xscale = (float)GP_r.r_width/2.0;
    xoffs = (float)GP_r.r_width/2.0 + (float)GP_r.r_left;
    yscale = -(float)GP_r.r_height/2.0;
    yoffs = (float)GP_r.r_top + (float)GP_r.r_height/2.0;
    zscale = (float)0xffff;
    zoffs = 0.0;
    use_mat_num = 0;
    set_mat_num = 0;
    matrix_3d = &id_3d;
    zbuf_depth = 0xffff;
    zbuf_x = GP_r.r_left;
    zbuf_y = GP_r.r_top;
    zbuf_width = GP_r.r_width;
    zbuf_height = GP_r.r_height;
    depth_cue = GP1_DEPTH_CUE_OFF;
    depth_cue_front_color = 0xffffff;
    depth_cue_back_color = 0x0;
    hidden_surf = GP1_NOHIDDENSURF;
    rgb_color = 0xffffff;
    rgb_color_red = 1.0;
    rgb_color_green = 1.0;
    rgb_color_blue = 1.0;

    TRACE_OUT

}

/**********************************************************************/
char *
ctx_post()
/**********************************************************************/
/* sets context attributes */

{
    register int i;
    register int j;
    Rect *r;
    short *p;

    func_name = "ctx_post";
    TRACE_IN

    p = allocbuf();
    if (p == (short *)-1) {
	TRACE_OUT
	return (errmsg_list[52]);
    }

    if (!dont_clear_ctx) {
	*p++ = GP1_CLEAR_CONTEXT;
    }

    *p++ = GP1_SET_FB_NUM | fb_num;

    *p++ = GP3_SET_FB_PLANES_RGB;
    GP1_PUT_I(p, fb_planes);

    *p++ = GP1_SET_ROP;
    *p++ = rop;

    *p++ = GP1_SET_CLIP_LIST;
    *p++ = ncliprect;
    for (i = ncliprect, r = cliprects ; i > 0 ; i--) {
	*p++ = r->r_left;
	*p++ = r->r_top;
	*p++ = r->r_width;
	*p++ = r->r_height;
	r++;
    }

    *p++ = GP1_SET_CLIP_PLANES | clip_planes;

    *p++ = GP1_SET_LINE_WIDTH;
    *p++ = line_width; *p++ = line_width_opt;

    *p++ = GP1_SET_LINE_TEX;
    do {
	*p++ = *pr_tex_ptr;
    } while (*pr_tex_ptr++);
    *p++ = pr_tex_offset; *p++ = pr_tex_options;

    *p++ = GP1_SET_VWP_3D;
    GP1_PUT_F(p, xscale); GP1_PUT_F(p, xoffs);
    GP1_PUT_F(p, yscale); GP1_PUT_F(p, yoffs);
    GP1_PUT_F(p, zscale); GP1_PUT_F(p, zoffs);

    *p++ = GP1_SET_MAT_3D | set_mat_num;
    for (i = 0 ; i < 4 ; i++) {
	for (j = 0 ; j < 4 ; j++) {
	    GP1_PUT_F(p, matrix_3d->m[i][j]);
	}
    }

    *p++ = GP1_SET_MAT_NUM | use_mat_num;

    if (!dont_clear_ctx) {
	*p++ = GP1_SET_ZBUF;
	*p++ = zbuf_depth;
	*p++ = zbuf_x;
	*p++ = zbuf_y;
	*p++ = zbuf_width;
	*p++ = zbuf_height;
    }


    *p++ = GP1_SET_HIDDEN_SURF | hidden_surf;

    *p++ = GP1_SET_DEPTH_CUE | depth_cue;
    *p++ = GP1_SET_DEPTH_CUE_COLORS | GP2_RGB_COLOR_PACK;
    GP1_PUT_I(p, depth_cue_front_color);
    GP1_PUT_I(p, depth_cue_back_color);

    *p++ = GP2_SET_RGB_COLOR | GP2_RGB_COLOR_PACK;
    GP1_PUT_I(p, rgb_color);

    if (postbuf(p)) {
	TRACE_OUT
	return(errmsg_list[26]);
    } else {
	gp1_sync(GP_shmem, GP_fd);
	TRACE_OUT
	return  (char *)0;
    }
}

/**********************************************************************/
char *
set_3D_matrix(n, mp)
/**********************************************************************/
int n;
Matrix_3D *mp;
/* sets load the matrix slot n with the matrix pointed to by mp */

{
    register short *p;
    register int i;
    register int j;
    unsigned char mat_num;

    func_name = "set_3D_matrix";
    TRACE_IN

    mat_num = (unsigned char) n;

    p = allocbuf();
    if (p == (short *)-1) {
	TRACE_OUT
	return (errmsg_list[52]);
    }
    *p++ = GP1_SET_MAT_3D | mat_num;
    for (i = 0 ; i < 4 ; i++) {
	for (j = 0 ; j < 4 ; j++) {
	    GP1_PUT_F(p, mp->m[i][j]);
	}
    }

    if (postbuf(p)) {
	TRACE_OUT
	return(errmsg_list[26]);
    } else {
	gp1_sync(GP_shmem, GP_fd);
	TRACE_OUT
	return  (char *)0;
    }
}


/**********************************************************************/
clear_all()
/**********************************************************************/
/* clears all pixrect planes of the GP */
{
    func_name = "clear_all";
    TRACE_IN

    pr_clear_all(GP_pr);

    TRACE_OUT
}

/**********************************************************************/
clear_24bit_plane()
/**********************************************************************/
/* clear only the 24-bit plane */
{
    func_name = "clear_24bit_plane";
    TRACE_IN

    /* set plane group and attributes */
    pr_set_planes(GP_pr, PIXPG_24BIT_COLOR, PIX_ALL_PLANES);

    pr_clear(GP_pr, PIX_CLR);

    TRACE_OUT
}

/**********************************************************************/
char *
pr_arbi_test()
/**********************************************************************/
{
    extern char *pr_all_test();
    char *errmsg;

    func_name = "pr_arbi_test";
    TRACE_IN

    pr_set_planes(GP_pr, PIXPG_24BIT_COLOR, PIX_ALL_PLANES);
    pr_dbl_set(GP_pr, PR_DBL_DISPLAY, PR_DBL_BOTH,
		    PR_DBL_WRITE, PR_DBL_BOTH,
		    PR_DBL_READ, PR_DBL_BOTH,
		    PR_DBL_DISPLAY_DONTBLOCK, PR_DBL_BOTH,
		    0);
    errmsg = pr_all_test(GP_pr, PIXPG_24BIT_COLOR);

    TRACE_OUT
    return errmsg;

}

/**********************************************************************/
rgb_stripes()
/**********************************************************************/
{
    int err;

    func_name = "rgb_stripes";
    TRACE_IN

    err = pr_rgb_stripes(GP_pr);

    TRACE_OUT
    return err;
}


/**********************************************************************/
box(xmin, ymin, xmax, ymax)
/**********************************************************************/
int xmin;
int ymin;
int xmax;
int ymax;

{
    pr_set_planes(GP_pr, PIXPG_24BIT_COLOR, PIX_ALL_PLANES);

    pr_rop(GP_pr, xmin, ymin, xmax-xmin, 1, PIX_SET, (Pixrect *)0, 0, 0);
    pr_rop(GP_pr, xmax, ymin, 1, ymax-ymin, PIX_SET, (Pixrect *)0, 0, 0);
    pr_rop(GP_pr, xmin, ymax, xmax-xmin, 1, PIX_SET, (Pixrect *)0, 0, 0);
    pr_rop(GP_pr, xmin, ymin, 1, ymax-ymin, PIX_SET, (Pixrect *)0, 0, 0);
}
    
/* just to run the C30 simulator */
#ifdef RFS
tmessage() {}
pr_clear() {}
pr_clear_all() {}
pmessage() {}
error_report() {}
#endif RFS

/*
 * Put a call to the print routine below inside your trace code
 *
 * i.e.
 *	prt_shm_blocks();
 */

prt_shm_blocks()
{
	register int block;
	register short freeh, freel;
	register struct gp1_shmem *shp = (struct gp1_shmem *) GP_shmem;

	if (shp->alloc_sem)
	    printf("allocation semaphore is on\n");

	freeh = ~(shp->gp_alloc_h ^ shp->host_alloc_h);
	freel = ~(shp->gp_alloc_l ^ shp->host_alloc_l);

	for (block=0; block<16; block++)
		fputc(((1 << block) & freeh) ? '1' : '.', stdout);
	
	fputc(' ',stdout);

	for (block=0; block<16; block++)
		fputc(((1 << block) & freel) ? '1' : '.', stdout);

	fputc('\n',stdout);
}