Beispiel #1
0
//alternate interpreter for morphing object
bool g3_draw_morphing_model(ubyte *p,grs_bitmap **model_bitmaps,vms_angvec *anim_angles,g3s_lrgb model_light,vms_vector *new_points)
{
	fix *glow_values = NULL;

	glow_num = -1;		//glow off by default

	while (w(p) != OP_EOF)

		switch (w(p)) {

			case OP_DEFPOINTS: {
				int n = w(p+2);

				rotate_point_list(Interp_point_list,new_points,n);
				p += n*sizeof(struct vms_vector) + 4;

				break;
			}

			case OP_DEFP_START: {
				int n = w(p+2);
				int s = w(p+4);

				rotate_point_list(&Interp_point_list[s],new_points,n);
				p += n*sizeof(struct vms_vector) + 8;

				break;
			}

			case OP_FLATPOLY: {
				int nv = w(p+2);
				int i,ntris;

				gr_setcolor(w(p+28));
				
				for (i=0;i<2;i++)
					point_list[i] = Interp_point_list + wp(p+30)[i];

				for (ntris=nv-2;ntris;ntris--) {

					point_list[2] = Interp_point_list + wp(p+30)[i++];

					g3_check_and_draw_poly(3,point_list,NULL,NULL);

					point_list[1] = point_list[2];

				}

				p += 30 + ((nv&~1)+1)*2;
					
				break;
			}

			case OP_TMAPPOLY: {
				int nv = w(p+2);
				g3s_uvl *uvl_list;
				g3s_lrgb light, *lrgb_list;
				g3s_uvl morph_uvls[3];
				int i,ntris;

				MALLOC(lrgb_list, g3s_lrgb, nv);

				//calculate light from surface normal
				if (glow_num < 0) //no glow
				{
					light.r = light.g = light.b = -vm_vec_dot(&View_matrix.fvec,vp(p+16));
					light.r = f1_0/4 + (light.r*3)/4;
					light.r = fixmul(light.r,model_light.r);
					light.g = f1_0/4 + (light.g*3)/4;
					light.g = fixmul(light.g,model_light.g);
					light.b = f1_0/4 + (light.b*3)/4;
					light.b = fixmul(light.b,model_light.b);
				}
				else //yes glow
				{
					light.r = light.g = light.b = glow_values[glow_num];
					glow_num = -1;
				}

				//now poke light into l values
				uvl_list = (g3s_uvl *) (p+30+((nv&~1)+1)*2);

				for (i=0;i<nv;i++)
				{
					lrgb_list[i].r = light.r;
					lrgb_list[i].g = light.g;
					lrgb_list[i].b = light.b;
				}

				for (i=0;i<3;i++)
					morph_uvls[i].l = (light.r+light.g+light.b)/3;

				for (i=0;i<2;i++) {
					point_list[i] = Interp_point_list + wp(p+30)[i];

					morph_uvls[i].u = uvl_list[i].u;
					morph_uvls[i].v = uvl_list[i].v;
				}

				for (ntris=nv-2;ntris;ntris--) {

					point_list[2] = Interp_point_list + wp(p+30)[i];
					morph_uvls[2].u = uvl_list[i].u;
					morph_uvls[2].v = uvl_list[i].v;
					i++;

					g3_check_and_draw_tmap(3,point_list,uvl_list,lrgb_list,model_bitmaps[w(p+28)],NULL,NULL);

					point_list[1] = point_list[2];
					morph_uvls[1].u = morph_uvls[2].u;
					morph_uvls[1].v = morph_uvls[2].v;

				}

				p += 30 + ((nv&~1)+1)*2 + nv*12;
				d_free(lrgb_list);

				break;
			}

			case OP_SORTNORM:

				if (g3_check_normal_facing(vp(p+16),vp(p+4)) > 0) {		//facing

					//draw back then front

					g3_draw_morphing_model(p+w(p+30),model_bitmaps,anim_angles,model_light,new_points);
					g3_draw_morphing_model(p+w(p+28),model_bitmaps,anim_angles,model_light,new_points);

				}
				else {			//not facing.  draw front then back

					g3_draw_morphing_model(p+w(p+28),model_bitmaps,anim_angles,model_light,new_points);
					g3_draw_morphing_model(p+w(p+30),model_bitmaps,anim_angles,model_light,new_points);
				}

				p += 32;

				break;


			case OP_RODBM: {
				g3s_point rod_bot_p,rod_top_p;
				g3s_lrgb rodbm_light = { f1_0, f1_0, f1_0 };

				g3_rotate_point(&rod_bot_p,vp(p+20));
				g3_rotate_point(&rod_top_p,vp(p+4));

				g3_draw_rod_tmap(model_bitmaps[w(p+2)],&rod_bot_p,w(p+16),&rod_top_p,w(p+32),rodbm_light);

				p+=36;
				break;
			}

			case OP_SUBCALL: {
				vms_angvec *a;

				if (anim_angles)
					a = &anim_angles[w(p+2)];
				else
					a = &zero_angles;

				g3_start_instance_angles(vp(p+4),a);

				g3_draw_polygon_model(p+w(p+16),model_bitmaps,anim_angles,model_light,glow_values);

				g3_done_instance();

				p += 20;

				break;

			}

			case OP_GLOW:

				if (glow_values)
					glow_num = w(p+2);
				p += 4;
				break;
		}

	return 1;
}
Beispiel #2
0
//calls the object interpreter to render an object.  The object renderer
//is really a seperate pipeline. returns true if drew
bool g3_draw_polygon_model(void *model_ptr, grs_bitmap **model_bitmaps, vms_angvec *anim_angles, fix model_light, fix *glow_values) {
	ubyte *p = (ubyte*)model_ptr;
	int current_poly = 0;

	glow_num = -1;		//glow off by default

	while (w(p) != OP_EOF)

		switch (w(p)) {

		case OP_DEFPOINTS: {
			int n = w(p + 2);

			rotate_point_list(Interp_point_list, vp(p + 4), n);
			p += n*sizeof(struct vms_vector) + 4;

			break;
		}

		case OP_DEFP_START: {
			int n = w(p + 2);
			int s = w(p + 4);

			rotate_point_list(&Interp_point_list[s], vp(p + 8), n);
			p += n*sizeof(struct vms_vector) + 8;

			break;
		}

		case OP_FLATPOLY: {
			int nv = w(p + 2);

			Assert(nv < MAX_POINTS_PER_POLY);
			if (g3_check_normal_facing(vp(p + 4), vp(p + 16)) > 0) {
				int i;

				gr_setcolor(w(p + 28));

				for (i = 0; i<nv; i++)
					point_list[i] = Interp_point_list + wp(p + 30)[i];

				g3_draw_poly(nv, point_list);
			}

			p += 30 + ((nv&~1) + 1) * 2;

			break;
		}

		case OP_TMAPPOLY: {
			int nv = w(p + 2);
			g3s_uvl *uvl_list;

			Assert(nv < MAX_POINTS_PER_POLY);
			if (g3_check_normal_facing(vp(p + 4), vp(p + 16)) > 0) {
				int i;
				fix light;

				//calculate light from surface normal

				if (glow_num < 0) {			//no glow

					light = -vm_vec_dot(&View_matrix.fvec, vp(p + 16));
					light = f1_0 / 4 + (light * 3) / 4;
					light = fixmul(light, model_light);
				}
				else {				//yes glow
					light = glow_values[glow_num];
					glow_num = -1;
				}

				//now poke light into l values

				uvl_list = (g3s_uvl *)(p + 30 + ((nv&~1) + 1) * 2);

				for (i = 0; i<nv; i++)
					uvl_list[i].l = light;

				for (i = 0; i<nv; i++)
					point_list[i] = Interp_point_list + wp(p + 30)[i];

				g3_draw_tmap(nv, point_list, uvl_list, model_bitmaps[w(p + 28)]);
			}

			p += 30 + ((nv&~1) + 1) * 2 + nv * 12;

			break;
		}

		case OP_SORTNORM:

			if (g3_check_normal_facing(vp(p + 16), vp(p + 4)) > 0) {		//facing

																			//draw back then front

				g3_draw_polygon_model(p + w(p + 30), model_bitmaps, anim_angles, model_light, glow_values);
				g3_draw_polygon_model(p + w(p + 28), model_bitmaps, anim_angles, model_light, glow_values);

			}
			else {			//not facing.  draw front then back

				g3_draw_polygon_model(p + w(p + 28), model_bitmaps, anim_angles, model_light, glow_values);
				g3_draw_polygon_model(p + w(p + 30), model_bitmaps, anim_angles, model_light, glow_values);
			}

			p += 32;

			break;


		case OP_RODBM: {
			g3s_point rod_bot_p, rod_top_p;

			g3_rotate_point(&rod_bot_p, vp(p + 20));
			g3_rotate_point(&rod_top_p, vp(p + 4));

			g3_draw_rod_tmap(model_bitmaps[w(p + 2)], &rod_bot_p, w(p + 16), &rod_top_p, w(p + 32), f1_0);

			p += 36;
			break;
		}

		case OP_SUBCALL: {
			vms_angvec *a;

			if (anim_angles)
				a = &anim_angles[w(p + 2)];
			else
				a = &zero_angles;

			g3_start_instance_angles(vp(p + 4), a);

			g3_draw_polygon_model(p + w(p + 16), model_bitmaps, anim_angles, model_light, glow_values);

			g3_done_instance();

			p += 20;

			break;

		}

		case OP_GLOW:

			if (glow_values)
				glow_num = w(p + 2);
			p += 4;
			break;

		default:
			Int3();
		}
	return 1;
}
Beispiel #3
0
//calls the object interpreter to render an object.  The object renderer
//is really a seperate pipeline. returns true if drew
bool g3_draw_polygon_model(ubyte *p,grs_bitmap **model_bitmaps,vms_angvec *anim_angles,g3s_lrgb model_light,fix *glow_values)
{

	glow_num = -1;		//glow off by default

	while (w(p) != OP_EOF)

		switch (w(p)) {

			case OP_DEFPOINTS: {
				int n = w(p+2);

				rotate_point_list(Interp_point_list,vp(p+4),n);
				p += n*sizeof(struct vms_vector) + 4;

				break;
			}

			case OP_DEFP_START: {
				int n = w(p+2);
				int s = w(p+4);

				rotate_point_list(&Interp_point_list[s],vp(p+8),n);
				p += n*sizeof(struct vms_vector) + 8;

				break;
			}

			case OP_FLATPOLY: {
				int nv = w(p+2);

				Assert( nv < MAX_POINTS_PER_POLY );
				if (g3_check_normal_facing(vp(p+4),vp(p+16)) > 0) {
					int i;
#ifdef FADE_FLATPOLY
					short c;
					unsigned char cc;
					int l;
#endif

//					DPH: Now we treat this color as 15bpp
//					gr_setcolor(w(p+28));
					
#ifndef FADE_FLATPOLY
					gr_setcolor(gr_find_closest_color_15bpp(w(p + 28)));
#else
					//l = (32 * model_light) >> 16;
					l = f2i(fixmul(i2f(32), (model_light.r+model_light.g+model_light.b)/3));
					if (l<0) l = 0;
					else if (l>32) l = 32;
					cc = gr_find_closest_color_15bpp(w(p+28));
					c = gr_fade_table[(l<<8)|cc];
					gr_setcolor(c);
#endif

					for (i=0;i<nv;i++)
						point_list[i] = Interp_point_list + wp(p+30)[i];

					g3_draw_poly(nv,point_list);
				}

				p += 30 + ((nv&~1)+1)*2;
					
				break;
			}

			case OP_TMAPPOLY: {
				int nv = w(p+2);
				g3s_uvl *uvl_list;

				Assert( nv < MAX_POINTS_PER_POLY );
				if (g3_check_normal_facing(vp(p+4),vp(p+16)) > 0) {
					int i;
					g3s_lrgb light, *lrgb_list;

					MALLOC(lrgb_list, g3s_lrgb, nv);
					//calculate light from surface normal
					if (glow_num < 0) //no glow
					{
						light.r = light.g = light.b = -vm_vec_dot(&View_matrix.fvec,vp(p+16));
						light.r = f1_0/4 + (light.r*3)/4;
						light.r = fixmul(light.r,model_light.r);
						light.g = f1_0/4 + (light.g*3)/4;
						light.g = fixmul(light.g,model_light.g);
						light.b = f1_0/4 + (light.b*3)/4;
						light.b = fixmul(light.b,model_light.b);
					}
					else //yes glow
					{
						light.r = light.g = light.b = glow_values[glow_num];
						glow_num = -1;
					}

					//now poke light into l values
					uvl_list = (g3s_uvl *) (p+30+((nv&~1)+1)*2);

					for (i=0;i<nv;i++)
					{
						uvl_list[i].l = (light.r+light.g+light.b)/3;
						lrgb_list[i].r = light.r;
						lrgb_list[i].g = light.g;
						lrgb_list[i].b = light.b;
					}

					for (i=0;i<nv;i++)
						point_list[i] = Interp_point_list + wp(p+30)[i];

					g3_draw_tmap(nv,point_list,uvl_list,lrgb_list,model_bitmaps[w(p+28)]);
					d_free(lrgb_list);
				}

				p += 30 + ((nv&~1)+1)*2 + nv*12;
					
				break;
			}

			case OP_SORTNORM:

				if (g3_check_normal_facing(vp(p+16),vp(p+4)) > 0) {		//facing

					//draw back then front

					g3_draw_polygon_model(p+w(p+30),model_bitmaps,anim_angles,model_light,glow_values);
					g3_draw_polygon_model(p+w(p+28),model_bitmaps,anim_angles,model_light,glow_values);

				}
				else {			//not facing.  draw front then back

					g3_draw_polygon_model(p+w(p+28),model_bitmaps,anim_angles,model_light,glow_values);
					g3_draw_polygon_model(p+w(p+30),model_bitmaps,anim_angles,model_light,glow_values);
				}

				p += 32;

				break;


			case OP_RODBM: {
				g3s_point rod_bot_p,rod_top_p;
				g3s_lrgb rodbm_light = { f1_0, f1_0, f1_0 };

				g3_rotate_point(&rod_bot_p,vp(p+20));
				g3_rotate_point(&rod_top_p,vp(p+4));

				g3_draw_rod_tmap(model_bitmaps[w(p+2)],&rod_bot_p,w(p+16),&rod_top_p,w(p+32),rodbm_light);

				p+=36;
				break;
			}

			case OP_SUBCALL: {
				vms_angvec *a;

				if (anim_angles)
					a = &anim_angles[w(p+2)];
				else
					a = &zero_angles;

				g3_start_instance_angles(vp(p+4),a);

				g3_draw_polygon_model(p+w(p+16),model_bitmaps,anim_angles,model_light,glow_values);

				g3_done_instance();

				p += 20;

				break;

			}

			case OP_GLOW:

				if (glow_values)
					glow_num = w(p+2);
				p += 4;
				break;

			default:
				Error("invalid polygon model\n");
		}
	return 1;
}
Beispiel #4
0
void draw_polygon_model(vms_vector *pos,vms_matrix *orient,vms_angvec *anim_angles,int model_num,int flags,g3s_lrgb light,fix *glow_values,bitmap_index alt_textures[])
{
	polymodel *po;
	int i;

	if (model_num < 0)
		return;

	Assert(model_num < N_polygon_models);

	po=&Polygon_models[model_num];

	//check if should use simple model
	if (po->simpler_model )					//must have a simpler model
		if (flags==0)							//can't switch if this is debris
			//!!if (!alt_textures) {				//alternate textures might not match
			//alt textures might not match, but in the one case we're using this
			//for on 11/14/94, they do match.  So we leave it in.
			{
				int cnt=1;
				fix depth;
	
				depth = g3_calc_point_depth(pos);		//gets 3d depth

				while (po->simpler_model && depth > cnt++ * Simple_model_threshhold_scale * po->rad)
					po = &Polygon_models[po->simpler_model-1];
			}

	if (alt_textures)
		for (i=0;i<po->n_textures;i++)	{
			texture_list_index[i] = alt_textures[i];
			texture_list[i] = &GameBitmaps[alt_textures[i].index];
		}
	else
		for (i=0;i<po->n_textures;i++)	{
			texture_list_index[i] = ObjBitmaps[ObjBitmapPtrs[po->first_texture+i]];
			texture_list[i] = &GameBitmaps[ObjBitmaps[ObjBitmapPtrs[po->first_texture+i]].index];
		}

	// Make sure the textures for this object are paged in...
	piggy_page_flushed = 0;
	for (i=0;i<po->n_textures;i++)	
		PIGGY_PAGE_IN( texture_list_index[i] );
	// Hmmm... cache got flushed in the middle of paging all these in,
	// so we need to reread them all in.
	if (piggy_page_flushed)	{
		piggy_page_flushed = 0;
		for (i=0;i<po->n_textures;i++)	
			PIGGY_PAGE_IN( texture_list_index[i] );
	}
	// Make sure that they can all fit in memory.
	Assert( piggy_page_flushed == 0 );

	g3_start_instance_matrix(pos,orient);

	g3_set_interp_points(robot_points);

	if (flags == 0)		//draw entire object

		g3_draw_polygon_model(po->model_data,texture_list,anim_angles,light,glow_values);

	else {
		int i;
	
		for (i=0;flags;flags>>=1,i++)
			if (flags & 1) {
				vms_vector ofs;

				Assert(i < po->n_models);

				//if submodel, rotate around its center point, not pivot point
	
				vm_vec_avg(&ofs,&po->submodel_mins[i],&po->submodel_maxs[i]);
				vm_vec_negate(&ofs);
				g3_start_instance_matrix(&ofs,NULL);
	
				g3_draw_polygon_model(&po->model_data[po->submodel_ptrs[i]],texture_list,anim_angles,light,glow_values);
	
				g3_done_instance();
			}	
	}

	g3_done_instance();

}