Пример #1
0
void msm6255_device::update_text(bitmap_ind16 &bitmap, const rectangle &cliprect)
{
	UINT8 hn = (m_hnr & HNR_HN_MASK) + 1;
	UINT8 vp = (m_pr & PR_VP_MASK) + 1;
	UINT8 nx = (m_dvr & DVR_DN_MASK) + 1;
	UINT16 sar = (m_sur << 8) | m_slr;

	int sy, y;

	update_cursor();

	for (sy = 0; sy < nx; sy++)
	{
		for (y = 0; y < vp; y++)
		{
			// draw upper half scanline
			UINT16 ma = sar + ((sy * vp) + y) * hn;
			draw_scanline(bitmap, cliprect, (sy * vp) + y, ma, y);

			// draw lower half scanline
			ma = sar + (((sy + nx) * vp) + y) * hn;
			draw_scanline(bitmap, cliprect, (sy * vp) + y, ma, y);
		}
	}
}
Пример #2
0
/*:::::*/
static void draw_ellipse(FB_GFXCTX *ctx, int x, int y, float a, float b, unsigned int color, int fill)
{
	int d, x1, y1, x2, y2;
	long long dx, dy, aq, bq, r, rx, ry;
	char filled[ctx->view_h];

	x1 = x - a;
	x2 = x + a;
	y1 = y2 = y;
	fb_hMemSet(filled, 0, ctx->view_h);
	
	if (!b) {
		draw_scanline(ctx, y, x1, x2, color, TRUE, filled);
		return;
	}
	else
		draw_scanline(ctx, y, x1, x2, color, fill, filled);
	
	aq = a * a;
	bq = b * b;
	dx = aq << 1;
	dy = bq << 1;
	r = a * bq;
	rx = r << 1;
	ry = 0;
	d = a;
	
	while (d > 0) {
		if (r > 0) {
			y1++;
			y2--;
			ry += dx;
			r -= ry;
		}
		if (r <= 0) {
			d--;
			x1++;
			x2--;
			rx -= dy;
			r += rx;
		}
		draw_scanline(ctx, y1, x1, x2, color, fill, filled);
		draw_scanline(ctx, y2, x1, x2, color, fill, filled);
	}
}
Пример #3
0
void msm6255_device::update_graphics(bitmap_ind16 &bitmap, const rectangle &cliprect)
{
	UINT8 hn = (m_hnr & HNR_HN_MASK) + 1;
	UINT8 nx = (m_dvr & DVR_DN_MASK) + 1;
	UINT16 sar = (m_sur << 8) | m_slr;

	int y;

	m_cursor = 0;
	m_frame = 0;

	for (y = 0; y < nx; y++)
	{
		// draw upper half scanline
		UINT16 ma = sar + (y * hn);
		draw_scanline(bitmap, cliprect, y, ma);

		// draw lower half scanline
		ma = sar + ((y + nx) * hn);
		draw_scanline(bitmap, cliprect, y + nx, ma);
	}
}
Пример #4
0
static void draw_ellipse
	(
		FB_GFXCTX *ctx,
		int x,
		int y,
		float a,
		float b,
		unsigned int color,
		int fill,
		int *top,
		int *bottom
	)
{
	int d, x1, y1, x2, y2;
	long long dx, dy, aq, bq, r, rx, ry;
	char filled[ctx->view_h];

	x1 = x - a;
	x2 = x + a;
	y1 = y2 = y;
	fb_hMemSet(filled, 0, ctx->view_h);

	if (!b) {
		draw_scanline(ctx, y, x1, x2, color, TRUE, filled);
		*top = y;
		*bottom = y;
		return;
	}

	draw_scanline(ctx, y, x1, x2, color, fill, filled);

	aq = a * a;
	bq = b * b;
	dx = aq << 1;
	dy = bq << 1;
	r = a * bq;
	rx = r << 1;
	ry = 0;
	d = a;

	while (d > 0) {
		if (r > 0) {
			y1++;
			y2--;
			ry += dx;
			r -= ry;
		}
		if (r <= 0) {
			d--;
			x1++;
			x2--;
			rx -= dy;
			r += rx;
		}
		draw_scanline(ctx, y1, x1, x2, color, fill, filled);
		draw_scanline(ctx, y2, x1, x2, color, fill, filled);
	}

	/* Tell caller exactly which rows were drawn so the SET_DIRTY() will be
	   correct */
	*top = y2;
	*bottom = y1;
}
Пример #5
0
/*======== void draw_polygons() ==========
Inputs: struct matrix *polygons
screen s
color c
Returns:


04/16/13 13:13:27
jdyrlandweaver
====================*/
void draw_polygons( struct matrix *polygons, screen s, color c ) {

    // ALL VARIABLES USED:
    int i, j;
    //int moe, curly, larry;
    int isCaseTwo = 0;
    double currentXFor, currentXTemp, currentY, currentZFor, currentZTemp;

    color cc;

    // INITIAL NAMES GIVEN TO COORDINATES OF THREE POINTS BEING EXAMINED
    double x1, x2, x3, y1, y2, y3, z1, z2, z3;

    //double drawX0, drawX1, drawZ0, drawZ1;

    // AMONG THE THREE POINTS, BOTTOM, MIDDLE, TOP
    double whyB, whyM, whyT;
    double exB, exM, exT;
    double zeeB, zeeM, zeeT;

    double delForeverX, delTempX; // delta zero and delta one in x
    double delForeverZ, delTempZ; // delta zero and delta one in z

    int x, z, d, dx, dz;

    double colorR, colorG, colorB;

    double maxY; // FOR LINES BETWEEN VERTICES OF A POLYGON

    // CHECK IF POLYGONS MATRIX IS VALID FOR DRAWING POLYGONS
    if ( polygons->lastcol < 3 ) {
        printf("Need at least 3 points to draw a polygon!\n");
        return;
    }
    printf("\n\n");

    // FOR LOOP TO GO THROUGH POLYGONS MATRIX, 3 POINTS AT A TIME
    for( i=0; i < polygons->lastcol-2; i+=3 ) {

        //MAKES EACH POLYGON A DIFFERENT COLOR, FOR TESTING
        //ambi.red = (ambi.red - 50) % 256;
        //ambi.green = (ambi.green + 75) % 256;
        //ambi.blue = (ambi.blue - 36) % 256;

        // CHECK IF POLYGON FACES VIEWER TO COMPLETE BACK FACE CULLING
        if ( calculate_dot( polygons, i ) >= 0 ) {
            // printf("drawing polygon %d\n", i/3);
            cc = allLight(polygons, i);/////////////////////////////////////////

            // SET COORDINATES TO RESPECTIVE POLYGON MATRIX VALUES
            x1 = polygons->m[0][i];
            y1 = polygons->m[1][i];
            z1 = polygons->m[2][i];

            x2 = polygons->m[0][i+1];
            y2 = polygons->m[1][i+1];
            z2 = polygons->m[2][i+1];

            x3 = polygons->m[0][i+2];
            y3 = polygons->m[1][i+2];
            z3 = polygons->m[2][i+2];


            // DRAW EDGES OF POLYGON MATRIX

            /*
               colorR = ambi.red;
               colorG = ambi.green;
               colorB = ambi.blue;

               ambi.red = 0;
               ambi.green = 0;
               ambi.blue = 0;

               draw_line( polygons->m[0][i],
               polygons->m[1][i],
               polygons->m[0][i+1],
               polygons->m[1][i+1],
               s, ambi);

               draw_line(polygons->m[0][i+1],
               polygons->m[1][i+1],
               polygons->m[0][i+2],
               polygons->m[1][i+2],
               s, ambi);

               draw_line( polygons->m[0][i+2],
               polygons->m[1][i+2],
               polygons->m[0][i],
               polygons->m[1][i],
               s, ambi);

               ambi.red = colorR;
               ambi.green = colorG;
               ambi.blue = colorB;
               */

            /*
               draw_line( polygons->m[0][i],
               polygons->m[1][i],
               polygons->m[0][i+1],
               polygons->m[1][i+1],
               s, c);

               draw_line( polygons->m[0][i+1],
               polygons->m[1][i+1],
               polygons->m[0][i+2],
               polygons->m[1][i+2],
               s, c);

               draw_line( polygons->m[0][i+2],
               polygons->m[1][i+2],
               polygons->m[0][i],
               polygons->m[1][i],
               s, c);
               */

            // DETERMINE IF TRIANGLE IS OF TYPE ONE
            if((y1 != y2) && (y2 != y3) && (y3 != y1)) {
                // Establishes bottom, middle, top y-coordinates in case 1 triangles

                // AS INITIAL STEP, MAKE BOTTOM COORDINATES CORRESPOND TO x1,y1,z1
                whyB = y1;
                exB = x1;
                zeeB = z1;

                // IF y2 IS LESS THAN whyB, SWITCH THE BOTTOM COORDINATES TO x2,y2,z2
                if((y2 < whyB)) {
                    whyB = y2;
                    exB = x2;
                    zeeB = z2;
                }

                // IF y3 IS LESS THAN whyB, SWITCH THE BOTTOM COORDINATES TO x3,y3,z3
                if((y3 < whyB)) {
                    whyB = y3;
                    exB = x3;
                    zeeB = z3;
                }

                // AS INITIAL STEP, MAKE TOP COORDINATES CORRESPOND TO x1,y1,z1
                whyT = y1;
                exT = x1;
                zeeT = z1;

                // IF y2 IS GREATER THAN whyT, SWITCH THE TOP COORDINATES TO x2,y2,z2
                if((y2 > whyT)) {
                    whyT = y2;
                    exT = x2;
                    zeeT = z2;
                }

                // IF y3 IS GREATER THAN whyT, SWITCH THE TOP COORDINATES TO x3,y3,z3
                if((y3 > whyT)) {
                    whyT = y3;
                    exT = x3;
                    zeeT = z3;
                }

                // IF y1 IS BETWEEN whyB AND whyT, MAKE IT whyM
                if((y1 > whyB) && (y1 < whyT)) {
                    whyM = y1;
                    exM = x1;
                    zeeM = z1;
                }

                // IF y2 IS BETWEEN whyB AND whyT, MAKE IT whyM
                if((y2 > whyB) && (y2 < whyT)) {
                    whyM = y2;
                    exM = x2;
                    zeeM = z2;
                }

                // IF y3 IS BETWEEN whyB AND whyT, MAKE IT whyM
                if((y3 > whyB) && (y3 < whyT)) {
                    whyM = y3;
                    exM = x3;
                    zeeM = z3;
                }

                // SET THE SLOPE FOR THE x0 AND THE TEMPORARY x1
                delForeverX = (exT - exB) / (whyT - whyB);
                delTempX = (exM - exB) / (whyM - whyB);

                delForeverZ = (zeeT - zeeB) / (whyT - whyB);
                delTempZ = (zeeM - zeeB) / (whyM - whyB);

                // SET THE STARTING y VALUE (currentY) TO whyB
                currentY = whyB;

                // WHILE LOOP THAT STOPS AT whyM, THE MIDDLE VERTEX
                while(currentY <= whyM) {

                    // SET THE TWO xS USING POINT-SLOPE FORM
                    currentXFor = exB + delForeverX * (currentY - whyB);
                    currentXTemp = exB + delTempX * (currentY - whyB);

                    currentZFor = zeeB + delForeverZ * (currentY - whyB);
                    currentZTemp = zeeB + delTempZ * (currentY - whyB);

                    // !!!!!!!!!!!!!!!!!!!!!!!!!!!!

                    //x = (int)currentXFor;
                    //z = (int)currentZFor;
                    x = currentXFor;
                    z = currentZFor;

                    //swap points so we're always drawing left to right
                    if ( currentXFor > currentXTemp ) {
                        //x = (int)currentXTemp;
                        x = currentXTemp;
                        //z = (int)currentZTemp;
                        z = currentZTemp;
                        //currentXTemp = (int)currentXFor; // signifies x1
                        currentXTemp = currentXFor;
                        //currentZTemp = (int)currentZFor; // signifies y1
                        currentZTemp = currentZFor;
                    }

                    draw_scanline(x, z, currentXTemp, currentY, currentZTemp, s, cc);

                    //draw_line(currentXFor, currentY, currentXTemp, currentY, s, c);

                    currentY++;
                }

                while((currentY > whyM) && (currentY <= whyT)) {
                    delTempX = (exT - exM) / (whyT - whyM);
                    currentXFor = exB + delForeverX * (currentY - whyB);
                    currentXTemp = exM + delTempX * (currentY - whyM);

                    delTempZ = (zeeT - zeeM) / (whyT - whyM);
                    currentZFor = zeeB + delForeverZ * (currentY - whyB);
                    currentZTemp = zeeM + delTempZ * (currentY - whyM);


                    x = currentXFor;
                    z = currentZFor;

                    //swap points so we're always drawing left to right
                    if ( currentXFor > currentXTemp ) {
                        //x = (int)currentXTemp;
                        x = currentXTemp;
                        //z = (int)currentZTemp;
                        z = currentZTemp;
                        //currentXTemp = (int)currentXFor; // signifies x1
                        currentXTemp = currentXFor;
                        //currentZTemp = (int)currentZFor; // signifies y1
                        currentZTemp = currentZFor;
                    }

                    draw_scanline(x, z, currentXTemp, currentY, currentZTemp, s, cc);

                    //draw_line(currentXFor, currentY, currentXTemp, currentY, s, c);

                    currentY++;
                }
            }

            if((y1 == y2) || (y2 == y3) || (y3 == y1)) {

                if(y1 == y2) {
                    if(y1 >= y3) {
                        isCaseTwo = 1;
                        whyB = y3;
                        exB = x3;
                        whyT = y1;
                        exT = x1;
                        whyM = y2;
                        exM = x2;
                    }

                    if(y1 < y3) {
                        isCaseTwo = 0;
                        whyT = y3;
                        whyB = y1;
                        whyM = y2;
                        exT = x3;
                        exB = x1;
                        exM = x2;
                    }
                }

                if(y2 == y3) {
                    if(y2 >= y1) {
                        isCaseTwo = 1;
                        whyB = y1;
                        whyT = y2;
                        whyM = y3;
                        exB = x1;
                        exT = x2;
                        exM = x3;
                    }
                    if(y2 < y1) {
                        isCaseTwo = 0;
                        whyB = y2;
                        whyT = y1;
                        whyM = y3;
                        exB = x2;
                        exT = x1;
                        exM = x3;
                    }
                }

                if(y3 == y1) {
                    if(y2 > y3) {
                        isCaseTwo = 0;
                        whyT = y2;
                        whyB = y3;
                        whyM = y1;
                        exT = x2;
                        exB = x3;
                        exM = x1;
                    }
                    if(y2 <= y3) {
                        isCaseTwo = 1;
                        whyT = y3;
                        whyM = y1;
                        whyB = y2;
                        exT = x3;
                        exM = x1;
                        exB = x2;
                    }

                }

                // CASES THAT HAVE NOT BEEN CHANGED YET:

                if(isCaseTwo == 0) {
                    currentY = whyB;
                    delForeverX = (exT - exB) / (whyT - whyB);
                    delTempX = (exT - exM) / (whyT - whyM);
                    while(currentY <= whyT) {
                        currentXFor = exB + delForeverX * (currentY - whyB);
                        currentXTemp = exM + delTempX * (currentY - whyM);


                        // IN THE ZONE AGAIN


                        x = currentXFor;
                        z = currentZFor;

                        //swap points so we're always drawing left to right
                        if ( currentXFor > currentXTemp ) {
                            //x = (int)currentXTemp;
                            x = currentXTemp;
                            //z = (int)currentZTemp;
                            z = currentZTemp;
                            //currentXTemp = (int)currentXFor; // signifies x1
                            currentXTemp = currentXFor;
                            //currentZTemp = (int)currentZFor; // signifies y1
                            currentZTemp = currentZFor;
                        }

                        draw_scanline(x, z, currentXTemp, currentY, currentZTemp, s, cc);

                        //draw_line(currentXFor, currentY, currentXTemp, currentY, s, c);

                        currentY++;
                    }
                }

                if(isCaseTwo == 1) {
                    currentY = whyB;
                    delForeverX = (exT - exB) / (whyT - whyB);
                    delTempX = (exM - exB) / (whyM - whyB);
                    while(currentY <= whyT) {
                        currentXFor = exB + delForeverX * (currentY - whyB);
                        currentXTemp = exB + delTempX * (currentY - whyB);


                        // MORE OF THE ZONE

                        x = currentXFor;
                        z = currentZFor;

                        //swap points so we're always drawing left to right
                        if ( currentXFor > currentXTemp ) {
                            //x = (int)currentXTemp;
                            x = currentXTemp;
                            //z = (int)currentZTemp;
                            z = currentZTemp;
                            //currentXTemp = (int)currentXFor; // signifies x1
                            currentXTemp = currentXFor;
                            //currentZTemp = (int)currentZFor; // signifies y1
                            currentZTemp = currentZFor;
                        }

                        draw_scanline(x, z, currentXTemp, currentY, currentZTemp, s, cc);

                        //draw_line(currentXFor, currentY, currentXTemp, currentY, s, c);
                        currentY++;
                    }
                }
            }

            colorR = cc.red;
            colorG = cc.green;
            colorB = cc.blue;
            /*
            cc.red = 0;
            cc.green = 0;
            cc.blue = 0;
            */
            draw_zL( polygons->m[0][i],
                     polygons->m[1][i],
                     polygons->m[2][i],
                     polygons->m[0][i+1],
                     polygons->m[1][i+1],
                     polygons->m[2][i+1],
                     s, cc);

            draw_zL( polygons->m[0][i+1],
                     polygons->m[1][i+1],
                     polygons->m[2][i+1],
                     polygons->m[0][i+2],
                     polygons->m[1][i+2],
                     polygons->m[2][i+2],
                     s, cc);

            draw_zL( polygons->m[0][i+2],
                     polygons->m[1][i+2],
                     polygons->m[2][i+2],
                     polygons->m[0][i],
                     polygons->m[1][i],
                     polygons->m[2][i],
                     s, cc);

            cc.red = colorR;
            cc.green = colorG;
            cc.blue = colorB;

            /*
            cc.red = ambiRed;
            cc.green = ambiGreen;
            cc.blue = ambiBlue;
            */
        }
    }

}