DJGPP 3D Polygon Tutorial Mode Z suppliment

(jeez! - that's a long URL...)

• It saved me having to allocate space in system memory for a double_buffer.
• It allowed me to clear out video memory four(4) pixels at a time.
• Page flipping took my computer and video card virtually NO time compared to moving the contents of a double_buffer to the video ram.

void Set_Mode_Z(void)
{
	// this function will set the video mode to 320x400x256

	int data;  // used to store data
	__dpmi_regs the_regs;

	// set system to mode 13h and use it as a foundation to base 320x400 mode on

	memset(&the_regs, 0, sizeof the_regs);    // is this memset really necessary???
	the_regs.x.ax = 0x13; /* 0x13 is the mode number */
	__dpmi_int(0x10, &the_regs);


	// make changes to the crt controller first

	outportb(CRT_CONTROLLER, CRT_MAX_SCANLINE);
	data=inportb(CRT_CONTROLLER+1);
	outportb(CRT_CONTROLLER+1, RESET_BITS(data,0x0f));

	// use byte addressing instead of word

	outportb(CRT_CONTROLLER,CRT_ADDR_MODE);
	data=inportb(CRT_CONTROLLER+1);
	outportb(CRT_CONTROLLER+1,RESET_BITS(data,0x40));

	// second register that needs to reflect byte addressing

	outportb(CRT_CONTROLLER,CRT_MODE_CONTROL);
	data=inportb(CRT_CONTROLLER+1);
	outportb(CRT_CONTROLLER+1,SET_BITS(data,0x40));

	// make changes to graphics controller

	// set addressing to not use odd/even memory writes

	outportb(GFX_CONTROLLER,GFX_WRITE_MODE);
	data=inportb(GFX_CONTROLLER+1);
	outportb(GFX_CONTROLLER+1,RESET_BITS(data,0x10));

	// don't chain the memory maps together

	outportb(GFX_CONTROLLER,GFX_MISC);
	data=inportb(GFX_CONTROLLER+1);
	outportb(GFX_CONTROLLER+1,RESET_BITS(data,0x02));

	// make changes to sequencer

	// again we must select no chaining and no odd/even memory addressing

	outportb(SEQUENCER,SEQ_MEMORY_MODE);
	data =inportb(SEQUENCER+1);
	data = RESET_BITS(data,0x08);
	data = SET_BITS(data,0x04);
	outportb(SEQUENCER+1,data);

	// now clear the screen

	outportb(SEQUENCER,SEQ_PLANE_ENABLE);
	outportb(SEQUENCER+1,0x0f);

	// clear the screen, remember it is 320x400, but that is divided into four
	// planes, hence we need only to clear 16 thousand bytes since there will be four planes
	// each being cleared in parallel for a total of 4*16,000 or 64000 = 320x400
	// note: "k" in this example means 1000 not 1024

	// clear BOTH pages

	rep_stosl(0x00,video_buffer,16000);

	// set screen width/height variables

	screen_width_mode = 80;
	screen_height_mode = 400;

} // end Set_Mode_Z

void Vert_Scan_Text_Planar_Clip(int column, int e_y1, int e_y2, int e_u1,
                                int e_u2, int e_v1, int e_v2, int text_shade)
{
    int pu1,pu2,pv1,pv2,py1,py2;

    int i;    // looping variable
    float linewidth; // used in the final drawing of a vertical strip

    long  uwidth,
          vwidth;

    long du,dv,u_curr,v_curr;	// the current u,v texture coordinates
    
    unsigned char color_me;
    
    int     x_index,   // looping variables
    	    y_index;
    int vert_strip;          // looping variables

    unsigned char *dest_addr;

    unsigned char *text; // texture pointer

    int planar_offset;

    text = textures.frames[textures.curr_frame];

    // start off working texture coordinates for current row
    
    py1 = e_y1;
    py2 = e_y2;
    pu1 = e_u1;
    pu2 = e_u2;
    pv1 = e_v1;
    pv2 = e_v2;
    
    // sort edges...
    if(py2<py1)
    {
        i=py1;
        py1=py2;
        py2=i;
    
        i=pu1;
        pu1=pu2;
        pu2=i;
    
        i=pv1;
        pv1=pv2;
        pv2=i;
    }
    
    // assign starting UxV coordinates
    
    u_curr = pu1<<16;
    v_curr = pv1<<16;
    
    linewidth=py2-py1;
    uwidth=pu2-pu1;
    vwidth=pv2-pv1;
    
    // calculate du,dv with respect to y
    
    du=(uwidth<<16)/(linewidth+1);
    dv=(vwidth<<16)/(linewidth+1);
    
    // clip texture as needed
    
    if (py1<0)
    {
        u_curr += (du * (float)(-py1));
        v_curr += (dv * (float)(-py1));
    
        py1 = 0;
    }
    
    if (py2 >=screen_height) py2 = (screen_height-1);
    
    // compute offset in the double buffer

    planar_offset = (column & 0x03);

    outportb(SEQUENCER,SEQ_PLANE_ENABLE);
    outportb(SEQUENCER+1,(0x01<<planar_offset));

    dest_addr = video_buffer+((int)py1<<6)+((int)py1<<4)+(column>>2);
    
    // render a verticle strip already!
    for (vert_strip=(int)py1; vert_strip <= (int)py2; vert_strip++)
    {
        // extract coordinates where a color will be copied
        // from in the texture...
    
        x_index = (int)(u_curr>>16);
        y_index = (int)(v_curr>>16);

       // extract pixel

        color_me = text[(y_index<<y_texture_shift) + x_index];
    
    // but this time, use it as part of an index into our
    // new color_table
    
        color_me = color_table[(int)color_me][text_shade];
    
        // plot the point
    
        *dest_addr = color_me;
    
        // move one line down in the video_buffer
    
        dest_addr += 80;
    
        // move to the next next (u,v) coordinate for the
        // texture to be used in this strip
    
        u_curr+=du;
        v_curr+=dv;
    }
} // end Vert_Scan_Text_Planar_Clip

    planar_offset = (column & 0x03);

    outportb(SEQUENCER,SEQ_PLANE_ENABLE);
    outportb(SEQUENCER+1,(0x01<<planar_offset));

    dest_addr = video_buffer+((int)py1<<6)+((int)py1<<4)+(column>>2);

if (!(double_buffer=(char *)malloc( (320*400) + 1 )) )
   // get out

    planar_offset = (column & 0x03) * 32000;

    dest_addr = double_buffer+((int)py1<<6)+((int)py1<<4)+(column>>2) + planar_offset;

        outportb(SEQUENCER, SEQ_PLANE_ENABLE);
        outportb(SEQUENCER+1, 0x01);
        rep_movsl(double_buffer, video_buffer, 8000);
        outportb(SEQUENCER, SEQ_PLANE_ENABLE);
        outportb(SEQUENCER+1, 0x02);
        rep_movsl(double_buffer+32000, video_buffer, 8000);
        outportb(SEQUENCER, SEQ_PLANE_ENABLE);
        outportb(SEQUENCER+1, 0x04);
        rep_movsl(double_buffer+64000, video_buffer, 8000);
        outportb(SEQUENCER, SEQ_PLANE_ENABLE);
        outportb(SEQUENCER+1, 0x08);
        rep_movsl(double_buffer+96000, video_buffer, 8000);

Download the Z mode demo & source code