assembley compiler+ line and circle algorithem

[Zelig]

אני פשוט לא מכיר את TC2.1 אז יותר מזה אני לא יכול לעזור. אבל באופן עקרוני מה שאתה מנסה אמור לעבוד בקומפיילרים של בורלנד. ייתכן ששלך פשוט ישן מדי.

[Ghosthunter]

תנסה למחוק את ההערות. קראתי עכשיו בעזרה של BORLAND(שתמיד מועיל לקרוא בה) שאי אפשר לשים הערות בתוך פקודות אסמבלי. כנראה שהקומפיילר רואה שזה באותה שורה ולא מאפשר לך.

תנסה לא יזיק.

[בלה]

בסוף הייתי צריך להוריד לתיקיה של tc את tasm.

בקשר להערות אתה לא בדיוק צודק.. אסור לכתוב ככה

asm mov ax, bx ; comments here

אבל מותר הערות c יחד עם assembly ככה

mov ax, bx /* comments */

דרך אגב תודה רבה שעניתם zelig ו- unsigned integer .

עכשיו רק את הבאגים המעצבנים ב- drawline נשאר לי למצוא draw_pixel והשאר עובד.

תודה רבה!

עריכה: הפונקציה draw_line שלי מציירת במקום קו אחד איזה 20 קווים באותו שיפוע אבל על כל המסך... ולפעמים יש איזה קו אחד או שניים אנכיים שלא צריך...

שאני עושה קוים אנכיים או אופקיים זה מצייר קו אחד בשיפוע הנכון אבל המיקום הוא לא זה שרציתי בכלל.

הקוד המקורי בפסאודו קוד הוא זה http://en.wikipedia.org/wiki/Bresenham's_line_algorithm

והנה הקוד שלי.. אני יכול להביא גם את כל התוכנית אבל כל שאר הפונקציות עובדות טוב.. מקווה שתבינו את הפונקציה.

void Draw_Line( short X1,short Y1,short X2,short Y2, char COLOR2)

{

short DELTAX; /* to store the absolute value of x2-x1*/

short DELTAY; /* to store the absolute value of y2-y1*/

short ERROR ; /* 2*error>deltax then y++ else y stay the same*/

char STEEP ; /* 0 if 0<m<1. or 1 if m>1*/

char XONE_BIGGER; /* 1 if x1>x2 else 0*/

char YONE_BIGGER; /* 1 if y1>y2 else 0*/

/* check if x0>x1 and calculate DELTAX according to that*/

asm push ax

Who_Is_Bigger(X1,X2);

asm mov [XONE_BIGGER], al

asm cmp al, 1

asm je x_one_bigger

xtwo_bigger:

asm mov ax, [X2]

asm sub ax, [X1]

asm mov [DELTAX], ax /* Deltax= X2-X1*/

asm jmp Delta_Y_Calc

x_one_bigger:

asm mov ax, [X1] /*Deltax= X1-X2 */

asm sub ax, [X2]

asm mov [DELTAX], ax

Delta_Y_Calc: /* now calculate DELTAY*/

Who_Is_Bigger(Y1,Y2);

asm mov [YONE_BIGGER], al

asm cmp al, 1

asm je y_one_bigger

ytwo_bigger:

asm mov ax, [Y2] /*Deltay= Y2-Y1 */

asm sub ax, [Y1]

asm mov [DELTAY], ax

asm jmp Steep_Calc

y_one_bigger:

asm mov ax, [Y1] /*Deltay= Y1-Y2*/

asm sub ax, [Y2]

asm mov [DELTAY], ax

Steep_Calc: /* Calculates Steep Value, 1 if m>1, and 0 if 0<m<1*/

Who_Is_Bigger(DELTAY,DELTAX); /* if Deltay>Deltax then steep 1, else steep 0*/

asm mov [sTEEP], al

/* now checking if theres a need in Swap*/

asm mov al, 0

asm cmp [sTEEP], al

asm je check_x0_x1

/* swapping cause m>1*/

Swap(&X1,&Y1);

Swap(&X2,&Y2);

check_x0_x1:

asm mov al, 1

asm cmp [XONE_BIGGER] ,al

asm js before_draw

/* swapping cause x0>x1*/

Swap(&X1, &X2);

Swap (&Y1, &Y2);

before_draw:

asm mov cx, DELTAX /* for x=xone to x=xtwo*/

draw:

asm mov al, 1

asm cmp [sTEEP], al

asm je plot_opposite

plot_normal:

Put_Pixel(X1,Y1,COLOR2); /* plot(x,y)*/

asm jmp change_error

plot_opposite:

Put_Pixel(Y1,X1,COLOR2); /* plot(y,x)*/

change_error:

asm mov ax, [DELTAY]

asm add [ERROR], ax /* error= error+DELTAY*/

check_error:

asm mov ax, [ERROR]

asm shl ax, 1 /* error= error*2*/

asm cmp ax, [DELTAX] /* cmp 2*error=deltax*/

asm js end_loop

/* if y1_bigger=1 then y=y-1 else y=y+1*/

asm mov al, 1

asm cmp al, [YONE_BIGGER]

asm je sub_y

asm add [Y1], al /* y1=y1+1*/

asm jmp deltax_error_calc

sub_y:

asm sub [Y1], al /*y1=y1-1*/

deltax_error_calc:

asm mov ax, [DELTAX]

asm sub [ERROR], ax /* error= error- DELTAX*/

end_loop:

asm mov ax, [X1] /* x1=x1+1*/

asm inc ax

asm mov [X1],ax

asm loop draw

end_proc_draw:

asm pop ax

}

[Zelig]

יתכן שהבעיה היא שהמשתנים שהגדרת הם על המחסנית כלומר ב-ss:[bp+something]

אני לא יודע עם TC ידע לתרגם [deltax] לביטוי הנכון כאשר deltax הוא משתנה על המחסנית.

בשלב ראשון תנסה להגדיר אותם כמשתנים גלובליים (מחוץ לפונקציה) רק בשביל לראות אם זה עוזר.

[בלה]

ל א עזר

[Zelig]

מצטער, אני לא יכול לעזור לך לדבג מרחוק, ואין לי זמן לרדת לעומק הקוד.

תוריד כמה tutorials וקוד של inline assembly. תסתכל איך עושים את זה שם, ואז תלמד מהם.