DOS下看真彩BMP位图的小程序（我给加了注释）

bierdaci

很久以前编的DOS看真彩BMP位图的小程序给贴上来了，有兴趣的就自己编译着玩玩，里边还有我写的一个画直线的算法，不过很笨拙。 初学者可以试着看看源码挺简单的，看到有不少人看这个贴子我就给注释了，不过画直线的函数就不用看了，很乱我自己都懒得看所以就没有注释
另外几个函数的功能在后面的跟贴我简单的介绍了一下



A.c main文件

1. 
   
2. #include <stdio.h>;
   
3. #include <conio.h>;
   
4. #include "a.h"
   
5. 
   
6. /*extern         void        print();
   
7. *extern  void        init(int);
   
8. *extern  void        vinfo(int)
   
9. *extern  void demo(int,int,int);
   
10. *extern  void Pixel16HiC(int,int,int);
    
11. *extern         void Pixel24TrC(unsigned long int,int,int);
    
12. *extern         void Pixel256C(char,int,int);
    
13. 
    
14. *#define         Hi15(R,G,B)
    
15. *#define  HiColor(R,G,B)    R*2048+G*32+B
    
16. *#define  TrColor(R,G,B)    R*65536+G*256+B
    
17. *#define  Tr_HColor(R,G,B)
    
18. *#define  H_TColor(RGB)
    
19. *#define  T_HColor(RGB)
    
20. */
    
21. 
    
22. 
    
23. 
    
24. main()
    
25. {
    
26.         unsigned int i,j,x,y;
    
27.         FILE *fp;
    
28. 
    
29.         if((fp=fopen("d:\\BC4\\Ship\\24.bmp","rb"))==NULL)/*自己选择路径*/
    
30.                 printf("Can't open 256.bmp\n");
    
31. 
    
32.         init(Tr800_600);/*初始化显示模式为24位真彩色，800*600分辨率*/
    
33. 
    
34.         readpic(fp);/*主函数*/
    
35.                 fclose(fp);
    
36. 
    
37.         /*for(i=0;i<=767;i++)
    
38.          *                line(i,i,1023,0,TrC(i,i*3,i/2));/*这里是画直线函数*/
    
39.                  */
    
40.                 getch();
    
41.         return;
    
42. }
    
43. 
    

复制代码

BMP.C 主文件，里边有画直线函数

1. 
   
2. #include<stdio.h>;
   
3. #include<alloc.h>;
   
4. #include<dos.h>;
   
5. #include"a.h"
   
6. 
   
7. 
   
8. 
   
9. unsigned        far* readpic(FILE *fp)
   
10. {
    
11. 
    
12.         struct bmp_head  far* bhead;
    
13.         int        x,y;
    
14.         unsigned long size,length,width;
    
15.         void far *        farmem;
    
16.         unsigned char        far *RGB;
    
17.         char        temp[30],over;
    
18. 
    
19. 
    
20.         fread(temp,30L,1,fp); /*读BMP文件头信息*/
    
21. 
    
22.         bhead=(char far*)temp;
    
23. 
    
24.         over=bhead->;width%4;/*BMP格式每行多出的位，我也不清楚为什么要多出这几位，当时我这里让我很头痛费了好大劲才查出来*/
    
25. 
    
26.         width=bhead->;width*3+over;/*位图宽*/
    
27. 
    
28.         if((farmem=farmalloc(width*10+10))==NULL)/*分配缓冲区因为DOS最大可分配内存是一个段64K字节这里我分配了位图宽度*10 +10*/
    
29.                 printf("Not enough Memory\n");
    
30. 
    
31.         fseek(fp,bhead->;offset,0);/*读指针跳到位图数据起点*/
    
32. 
    
33.         fread(farmem,width,10,fp);/*读位图数据到缓冲区*/
    
34.                
    
35.         RGB=farmem;/*RGB画像素用的指针，每像素3个字节*/
    
36. 
    
37.         for(y=bhead->;hight;y>;=0;y--)/*bhead->;hight 位图高度*/
    
38.         {
    
39.                 for(x=0;x<bhead->;width;x++)/*bhead->;width 位图宽度*/
    
40.                 {
    
41.                         Pixel24TrC(TrC(*(RGB+2),*(RGB+1),*RGB),x,y);/*画点*/
    
42.                         RGB=RGB+3;/*一个像素点3个字节*/
    
43.                         if(FP_OFF(RGB)==width*10+FP_OFF(farmem)||FP_OFF(RGB)==width*10+FP_OFF(farmem)+3)/*FP_OFF取远指针偏移，这个条件语句判断画完一个缓冲区*/
    
44.                         {
    
45.                                 fread(farmem,width,10,fp);
    
46.                                 RGB=farmem;
    
47.                         }/*把BMP位图分成缓冲区大小的段*/
    
48.                 }
    
49.                 RGB=RGB+over;/*每行最后多出over个字节*/
    
50.         }
    
51.         farfree(farmem);
    
52. 
    
53. 
    
54.         return        farmem;
    
55. 
    
56. }
    
57. 
    
58. 
    
59. /*画直线函数*/
    
60. 
    
61. void line(unsigned long left_x,unsigned long left_y,unsigned long right_x,unsigned long right_y,unsigned long color)
    
62. {
    
63. 
    
64.         unsigned long        x=left_x,y=left_y;
    
65.         if(left_x>;right_x)
    
66.                 if(left_y>;right_y)
    
67.                 {
    
68.                         while(left_x-right_x>;left_x-x)
    
69.                         {
    
70.                                 Pixel24TrC(color,x,y);
    
71.                                 if((left_x-right_x)>;(left_y-right_y))
    
72.                                         while((left_y-right_y)*(left_x-x)<(left_x-right_x)*(left_y-y))
    
73.                                         {
    
74.                                                 x--;
    
75.                                                 Pixel24TrC(color,x,y);
    
76.                                         }
    
77.                                 x--;
    
78.                                 if(y<=right_y)
    
79.                                         continue;
    
80.                                 if((left_y-right_y)>;(left_x-right_x))
    
81.                                         while((left_y-right_y)*(left_x-x)>;(left_x-right_x)*(left_y-y))
    
82.                                         {
    
83.                                                 y--;
    
84.                                                 Pixel24TrC(color,x,y);
    
85.                                         }
    
86.                                 y--;
    
87.                         };
    
88.                         while(y>;right_y)
    
89.                         {
    
90.                                 Pixel24TrC(color,x,y);
    
91.                                 y--;
    
92.                         };
    
93. 
    
94.                 }
    
95.                 else
    
96.                 {
    
97.                         while(x>;right_x)
    
98.                         {
    
99.                                 Pixel24TrC(color,x,y);
    
100.                                 if((left_x-right_x)>;(right_y-left_y))
     
101.                                         while((right_y-left_y)*(left_x-x)<(left_x-right_x)*(y-left_y))
     
102.                                         {
     
103.                                                 x--;
     
104.                                                 Pixel24TrC(color,x,y);
     
105.                                         }
     
106.                                 x--;
     
107.                                 if(!(y<right_y))
     
108.                                         continue;
     
109.                                 if((right_y-left_y)>;(left_x-right_x))
     
110.                                         while((right_y-left_y)*(left_x-x)>;(left_x-right_x)*(y-left_y))
     
111.                                         {
     
112.                                                 y++;
     
113.                                                 Pixel24TrC(color,x,y);
     
114.                                         }
     
115.                                 y++;
     
116.                         };
     
117. 
     
118.                         while(y<=right_y)
     
119.                         {
     
120.                                 Pixel24TrC(color,x,y);
     
121.                                 y++;
     
122.                         };
     
123.                 }
     
124. 
     
125.         else
     
126.                 if(left_y>;right_y)
     
127.                 {
     
128.                         while(x<right_x)
     
129.                         {
     
130.                                 Pixel24TrC(color,x,y);
     
131.                                 if((right_x-left_x)>;(left_y-right_y))
     
132.                                         while((left_y-right_y)*(x-left_x)<(right_x-left_x)*(left_y-y))
     
133.                                         {
     
134.                                                 x++;
     
135.                                                 Pixel24TrC(color,x,y);
     
136.                                         }
     
137.                                 x++;
     
138.                                 if(left_y-y>;left_y-right_y)
     
139.                                         continue;
     
140.                                 if((left_y-right_y)>;(right_x-left_x))
     
141.                                         while((left_y-right_y)*(x-left_x)>;(right_x-left_x)*(left_y-y))
     
142.                                         {
     
143.                                                 y--;
     
144.                                                 Pixel24TrC(color,x,y);
     
145.                                         }
     
146.                                 y--;
     
147.                         };
     
148. 
     
149.                         while(left_y-y<=left_y-right_y)
     
150.                         {
     
151.                                 Pixel24TrC(color,x,y);
     
152.                                 y--;
     
153.                         };
     
154. 
     
155.                 }
     
156.                 else
     
157.                 {
     
158.                         while(x<right_x)
     
159.                         {
     
160.                                 Pixel24TrC(color,x,y);
     
161.                                 if((right_x-left_x)>;(right_y-left_y))
     
162.                                         while((right_y-left_y)*(x-left_x)<(right_x-left_x)*(y-left_y))
     
163.                                         {
     
164.                                                 x++;
     
165.                                                 Pixel24TrC(color,x,y);
     
166.                                         }
     
167. 
     
168.                                 x++;
     
169. 
     
170.                                 if(y>;=right_y)
     
171.                                         continue;
     
172.                                 if((right_y-left_y)>;(right_x-left_x))
     
173.                                         while((right_y-left_y)*(x-left_x)>;(right_x-left_x)*(y-left_y))
     
174.                                         {
     
175.                                                 y++;
     
176.                                                 Pixel24TrC(color,x,y);
     
177.                                         }
     
178.                                 y++;
     
179.                         };
     
180. 
     
181.                         while(y<=right_y)
     
182.                         {
     
183.                                 Pixel24TrC(color,x,y);
     
184.                                 y++;
     
185.                         };
     
186.                 }
     
187. 
     
188.         return 0;
     
189. }
     
190. 
     
191. 
     

复制代码

a.h 头文件

1. 
   
2. #define        LINE        640
   
3. 
   
4. 
   
5. #define        C256(R,G,B)                (unsigned char)R*0x20%0x100+(unsigned char)G*0x4%0x20+B
   
6. 
   
7. #define         Hi15(R,G,B)                (unsigned)R*0x400%0x8000+(unsigned)G*0x20%0x400+(char)B%0x20
   
8. 
   
9. #define        HiC(R,G,B)                 (unsigned)R*0x800%0x10000+(unsigned)G*32%0x800+(char)B%0x20
   
10. #define        TrC(R,G,B)                (unsigned long)R*0x10000%0x1000000+(unsigned long)G*0x100%0x10000+(unsigned)B%0x100
    
11. #define        Hi-TrC(RGB)           (unsigned long)RGB%0x10000/2048*65536+(unsigned long)RGB%2048/32*256+(unsigned char)RGB%32
    
12. #define        Tr-HiC(RGB)                (unsigned long)RGB%0x1000000/65536%32*2048+(unsigned long)RGB%65536/64*32+(unsigned char)(RGB%32)
    
13. 
    
14. 
    
15. #define        C256_640_400                0x100
    
16. #define        C256_640_480                0x101
    
17. #define        C16_800_600                        0x102
    
18. #define        C256_800_600                0x103
    
19. #define        C16_1024_768                0x104
    
20. #define        C256_1024_768                0x105
    
21. #define        Hi15_640_480                0x110
    
22. #define        Hi640_480                        0x111
    
23. #define        Tr640_480         0x112
    
24. #define        Hi15_800_600                0x113
    
25. #define        Hi800_600                        0x114
    
26. #define        Tr800_600                        0x115
    
27. #define        Hi15_1024_768                0x116
    
28. #define        Hi1024_768                        0x117
    
29. #define        Tr1024_768                        0x118
    
30. 
    
31. 
    
32. 
    
33. 
    
34. extern        void  Demo(unsigned long,int,int);
    
35. 
    
36. extern        void        init(int);
    
37. extern      void Pixel16HiC(int,int,int);
    
38. extern        void Pixel24TrC(unsigned long,int,int);
    
39. extern        void Pixel256C(char,int,int);
    
40. extern      void line(unsigned long x1,unsigned long y1,unsigned long x2,unsigned long y2,unsigned long color);
    
41. 
    
42. /*seepic*/
    
43. extern        unsigned far* readpic(FILE *fp);
    
44. 
    
45. extern        void mouse(void);
    
46. 
    
47. 
    
48. struct        bmp_head
    
49. {
    
50.         int         other1;
    
51.         unsigned long        length;
    
52.         char        other2[4];
    
53.         unsigned  int        offset;
    
54.         char        other3[6];
    
55.         unsigned  int        width;
    
56.         char        other4[2];
    
57.         unsigned  int        hight;
    
58.         char                        other5[4];
    
59.         unsigned        char        color;
    
60. };
    

复制代码

mybmp.c这是嵌入式汇编的画点函数

1. 
   
2. void init(int mode)
   
3. {
   
4.         asm        mov                bx,mode
   
5.         asm         mov                ax,4f02h
   
6.         asm        int                10h
   
7.         return;
   
8. }
   
9. 
   
10. 
    
11. 
    
12. 
    
13. void Pixel24TrC(unsigned long color,int x,int y)
    
14. {
    
15. 
    
16.         asm         push                es
    
17.         asm        push                di
    
18. 
    
19.         asm        mov                ax,4f03h
    
20.         asm        int                10h
    
21. 
    
22. pi112:
    
23.         asm        cmp                 bx,112h
    
24.         asm        jnz                pi115
    
25. 
    
26.         asm        mov                dx,640
    
27.         asm        jmp                write_24t
    
28. 
    
29. 
    
30. pi115:
    
31.         asm        cmp                bx,115h
    
32.         asm        jnz                pi118
    
33. 
    
34.         asm        mov                dx,800
    
35.         asm        jmp                write_24t
    
36. 
    
37. pi118:
    
38.         asm        cmp                bx,118h
    
39.         asm        jnz                Tr_exit
    
40. 
    
41.         asm        mov                dx,1024
    
42. 
    
43. write_24t:
    
44.         asm        mov                ax,0a000h
    
45.         asm        mov                es,ax
    
46.         asm        mov                ax,y
    
47.         asm        mul                dx
    
48.         asm        mov                bx,ax
    
49.         asm        mov                cx,dx
    
50.         asm        add                ax,bx
    
51.         asm        adc                dx,cx
    
52.         asm        add                ax,bx
    
53.         asm        adc                dx,cx
    
54.         asm        add                ax,bx
    
55.         asm        adc                dx,cx
    
56. 
    
57.         asm        mov                bx,x
    
58.         asm        add                bx,x
    
59.         asm        add                bx,x
    
60.         asm        add                bx,x
    
61.         asm        add                ax,bx
    
62.         asm        adc                dx,0
    
63.         asm        mov                di,ax
    
64. 
    
65.         asm        mov                ax,4f05h
    
66.         asm        mov                bx,0
    
67.         asm        int                10h
    
68. 
    
69.         asm        mov                cx,word ptr color
    
70.         asm        mov                word ptr es:[di],cx
    
71.         asm        add                di,2
    
72.         asm        mov                cx,word ptr color+2
    
73.         asm        mov                word ptr es:[di],cx
    
74. 
    
75. Tr_exit:
    
76.         asm        pop                di
    
77.         asm        pop                es
    
78. 
    
79.         return;
    
80. }
    
81. 
    
82. 
    
83. void Pixel16HiC(int color,int x,int y)
    
84. {
    
85.         asm        push                es
    
86.         asm        push                di
    
87. 
    
88.         asm        mov                ax,4f03h
    
89.         asm        int                10h
    
90. 
    
91. pi110:
    
92.         asm        cmp                bx,110h
    
93.         asm        jnz                pi111
    
94. 
    
95.         asm        mov                dx,640
    
96.         asm        jmp                write_16h
    
97. 
    
98. 
    
99. 
    
100. pi111:
     
101.         asm        cmp                bx,111h
     
102.         asm        jnz                pi113
     
103. 
     
104.         asm        mov                dx,640
     
105.         asm        jmp                write_16h
     
106. 
     
107. 
     
108. 
     
109. pi113:
     
110.         asm        cmp                bx,113h
     
111.         asm        jnz                pi114
     
112. 
     
113.         asm        mov                dx,800
     
114.         asm        jmp                write_16h
     
115. 
     
116. 
     
117. pi114:
     
118.         asm        cmp                bx,114h
     
119.         asm        jnz                pi116
     
120. 
     
121.         asm        mov                dx,800
     
122.         asm        jmp                write_16h
     
123. 
     
124. 
     
125. pi116:
     
126.         asm        cmp                bx,116h
     
127.         asm        jnz                pi117
     
128. 
     
129.         asm        mov                dx,1024
     
130.         asm        jmp                write_16h
     
131. 
     
132. 
     
133. pi117:
     
134.         asm        cmp                bx,117h
     
135.         asm        jnz                Hi_exit
     
136. 
     
137.         asm        mov                dx,1024
     
138. 
     
139. 
     
140. write_16h:
     
141.         asm        mov                ax,0a000h
     
142.         asm        mov                es,ax
     
143.         asm        mov                ax,word ptr [y]
     
144.         asm        mul                dx
     
145.         asm        shl                ax,1
     
146.         asm        jc                        a1
     
147.         asm        shl                dx,1
     
148.         asm        jmp                cont
     
149. a1:
     
150.         asm        shl                dx,1
     
151.         asm        inc                dx
     
152. 
     
153. cont:
     
154.         asm        shl                word ptr [x],1
     
155.         asm        add                ax,word ptr [x]
     
156.         asm        adc                dx,0
     
157.         asm        mov      di,ax
     
158. 
     
159.         asm        mov                ax,4f05h
     
160.         asm        mov                bx,0
     
161.         asm        int                10h
     
162. 
     
163.         asm        mov                cx,word ptr [color]
     
164.         asm        mov                word ptr es:[di],cx
     
165. 
     
166. Hi_exit:
     
167.         asm        pop                di
     
168.         asm        pop                es
     
169. 
     
170.         return;
     
171. }
     
172. 
     
173. 
     
174. void Pixel256C(char        color,int x,int y)
     
175. {
     
176.         asm        push                es
     
177.         asm        push                di
     
178. 
     
179. 
     
180.         asm        mov                ax,4f03h
     
181.         asm        int                10h
     
182. 
     
183. 
     
184. pi100:
     
185.         asm        cmp                bx,100h
     
186.         asm        jnz                pi101
     
187. 
     
188.         asm        mov                dx,640
     
189.         asm        jmp                write_256
     
190. 
     
191. pi101:
     
192.         asm        cmp                bx,101h
     
193.         asm        jnz                pi103
     
194. 
     
195.         asm        mov                dx,640
     
196.         asm        jmp                write_256
     
197. 
     
198. 
     
199. 
     
200. pi103:
     
201.         asm        cmp                bx,103h
     
202.         asm        jnz                pi105
     
203. 
     
204.         asm        mov                dx,800
     
205.         asm        jmp                write_256
     
206. 
     
207. 
     
208. 
     
209. pi105:
     
210.         asm        cmp                bx,105h
     
211.         asm        jnz                exit_256
     
212. 
     
213.         asm        mov                dx,1024
     
214. 
     
215. write_256:
     
216.         asm        mov                ax,0a000h
     
217.         asm        mov                es,ax
     
218.         asm        mov                ax,word ptr [y]
     
219.         asm        mul                dx
     
220.         asm        add                ax,word ptr [x]
     
221.         asm        adc                dl,0
     
222.         asm        mov      di,ax
     
223. 
     
224.         asm        mov                ax,4f05h
     
225.         asm        mov                bx,0
     
226.         asm        int                10h
     
227. 
     
228.         asm        mov                cl,byte ptr [color]
     
229.         asm        mov                byte ptr es:[di],cl
     
230. 
     
231. 
     
232. exit_256:
     
233.         asm        pop                di
     
234.         asm        pop                es
     
235. 
     
236.         return;
     
237. }
     

复制代码

gl.asm 底层画点函数要用TASM编译，不过有上边的嵌入式汇编这个可以不用了

1. 
   
2. .386
   
3. 
   
4.                                         public          _init
   
5.                                         public        _Demo
   
6.                                         public   _Pixel16HiC
   
7.                                         public   _Pixel24TrC
   
8.                                         public   _Pixel256C
   
9. 
   
10. 
    
11. _ATTRI                     struc
    
12. 
    
13. MODE_ATTR           DW                ?
    
14. WIN_A_ATTR                DB                ?
    
15. WIN_B_ATTR                DB                ?
    
16. WIN_GRAN                        DB                ?
    
17. WIN_SIZE                        DW                ?
    
18. WIN_A_SEG                DW                ?
    
19. WIN_B_SEG                DW                ?
    
20. WIN_FUNC_PTR   DD                ?
    
21. LINE_BYTE                DW                ?
    
22. 
    
23. _ATTRI                    ends
    
24. 
    
25. 
    
26. 
    
27. mpusha                        macro
    
28.                                         push                ax
    
29.                                         push                cx
    
30.                                         push                dx
    
31.                                         push                bx
    
32.                                         push                sp
    
33.                                         push                bp
    
34.                                         push                si
    
35.                                         push                di
    
36.                                         endm
    
37. 
    
38. 
    
39. mpopa                                macro
    
40.                                         pop                di
    
41.                                         pop                si
    
42.                                         pop                bp
    
43.                                         pop                sp
    
44.                                         pop                bx
    
45.                                         pop                dx
    
46.                                         pop                cx
    
47.                                         pop                ax
    
48.                                         endm
    
49. 
    
50. 
    
51. DGROUP                        group                  _DATA,_BSS
    
52. 
    
53. 
    
54. 
    
55. 
    
56.                                         extrn                _printf:far
    
57. 
    
58. 
    
59. 
    
60. 
    
61. _TEXT                                segment        use16 byte public 'code'
    
62.                                         assume        cs:_TEXT,ds:DGROUP
    
63. 
    
64. 
    
65. ;初始化图型模式
    
66. ;入口参数：显示模式压入?
    
67. 
    
68. _init                     proc                far
    
69. 
    
70.                                         enterw          0,0
    
71.                                         mov                bx,[bp+6]
    
72.                                         mov                ax,4f02h
    
73.                                         int                10h
    
74.                                         leavew
    
75.                                         ret
    
76. 
    
77. _init                      endp
    
78. 
    
79. 
    
80. ;画点
    
81. 
    
82. 
    
83. 
    
84. _Pixel24TrC         proc                far
    
85. 
    
86.                                         enterw        0,0
    
87.                                         push                es
    
88.                                         push                di
    
89. 
    
90.                                         mov                ax,4f03h
    
91.                                         int                10h
    
92. 
    
93. pi112:                        cmp                 bx,112h
    
94.                                         jnz                pi115
    
95. 
    
96.                                         mov                dx,640
    
97.                                         jmp                write_24t
    
98. 
    
99. 
    
100. pi115:         cmp                bx,115h
     
101.                                         jnz                pi118
     
102. 
     
103.                                         mov                dx,800
     
104.                                         jmp                write_24t
     
105. 
     
106. pi118:                        cmp                bx,118h
     
107.                                         jnz                Tr_exit
     
108. 
     
109.                                         mov                dx,1024
     
110. 
     
111. write_24t:                mov                ax,0a000h
     
112.                                         mov                es,ax
     
113.                                         mov                ax,word ptr [bp+12]
     
114.                                         mul                dx
     
115.                                         mov                bx,ax
     
116.                                         mov                cx,dx
     
117.                                         add                ax,bx
     
118.                                         adc                dx,cx
     
119.                                         add                ax,bx
     
120.                                         adc                dx,cx
     
121.                                         add                ax,bx
     
122.                                         adc                dx,cx
     
123. 
     
124.                                         mov                bx,word ptr [bp+10]
     
125.                                         add                bx,word ptr [bp+10]
     
126.                                         add                bx,word ptr [bp+10]
     
127.                                         add                bx,word ptr [bp+10]
     
128.                                         add                ax,bx
     
129.                                         adc                dx,0
     
130.                                         mov                di,ax
     
131. 
     
132.                                         mov                ax,4f05h
     
133.                                         mov                bx,0
     
134.                                         int                10h
     
135. 
     
136.                                         mov                cx,word ptr [bp+6]
     
137.                                         mov                word ptr es:[di],cx
     
138.                                         add                di,2
     
139.                                         mov                cx,word ptr [bp+8]
     
140.                                         mov                word ptr es:[di],cx
     
141. 
     
142. Tr_exit:                        pop                di
     
143.                                         pop                es
     
144. 
     
145.                                         leavew
     
146.                                         ret
     
147. 
     
148. _Pixel24TrC                endp
     
149. 
     
150. 
     
151. 
     
152. 
     
153. _Pixel16HiC         proc                far
     
154. 
     
155.                                         enterw        0,0
     
156.                                         push                es
     
157.                                         push                di
     
158. 
     
159.                                         mov                ax,4f03h
     
160.                                         int                10h
     
161. 
     
162. pi110:                        cmp                bx,110h
     
163.                                         jnz                pi111
     
164. 
     
165.                                         mov                dx,640
     
166.                                         jmp                write_16h
     
167. 
     
168. 
     
169. 
     
170. pi111:         cmp                bx,111h
     
171.                                         jnz                pi113
     
172. 
     
173.                                         mov                dx,640
     
174.                                         jmp                write_16h
     
175. 
     
176. 
     
177. 
     
178. pi113:         cmp                bx,113h
     
179.                                         jnz                pi114
     
180. 
     
181.                                         mov                dx,800
     
182.                                         jmp                write_16h
     
183. 
     
184. 
     
185. pi114:         cmp                bx,114h
     
186.                                         jnz                pi116
     
187. 
     
188.                                         mov                dx,800
     
189.                                         jmp                write_16h
     
190. 
     
191. 
     
192. pi116:                        cmp                bx,116h
     
193.                                         jnz                pi117
     
194. 
     
195.                                         mov                dx,1024
     
196.                                         jmp                write_16h
     
197. 
     
198. 
     
199. pi117:         cmp                bx,117h
     
200.                                         jnz                Hi_exit
     
201. 
     
202.                                         mov                dx,1024
     
203. 
     
204. 
     
205. write_16h:                mov                ax,0a000h
     
206.                                         mov                es,ax
     
207.                                         mov                ax,word ptr [bp+10]
     
208.                                         mul                dx
     
209.                                         shl                ax,1
     
210.                                         jc                        a1
     
211.                                         shl                dx,1
     
212.                                         jmp                cont
     
213. a1:                                shl                dx,1
     
214.                                         inc                dx
     
215. 
     
216. cont:                                shl                word ptr [bp+8],1
     
217.                                         add                ax,word ptr [bp+8]
     
218.                                         adc                dx,0
     
219.                                         mov      di,ax
     
220. 
     
221.                                         mov                ax,4f05h
     
222.                                         mov                bx,0
     
223.                                         int                10h
     
224. 
     
225.                                         mov                cx,word ptr [bp+6]
     
226.                                         mov                word ptr es:[di],cx
     
227. 
     
228. Hi_exit:                        pop                di
     
229.                                         pop                es
     
230. 
     
231.                                         leavew
     
232.                                         ret
     
233. 
     
234. _Pixel16HiC                endp
     
235. 
     
236. 
     
237. 
     
238. 
     
239. _Pixel256C                 proc                far
     
240. 
     
241.                                         enterw        0,0
     
242.                                         push                es
     
243.                                         push                di
     
244. 
     
245. 
     
246.                                         mov                ax,4f03h
     
247.                                         int                10h
     
248. 
     
249. 
     
250. pi100:                        cmp                bx,100h
     
251.                                         jnz                pi101
     
252. 
     
253.                                         mov                dx,640
     
254.                                         jmp                write_256
     
255. 
     
256. pi101:                        cmp                bx,101h
     
257.                                         jnz                pi103
     
258. 
     
259.                                         mov                dx,640
     
260.                                         jmp                write_256
     
261. 
     
262. 
     
263. 
     
264. pi103:                        cmp                bx,103h
     
265.                                         jnz                pi105
     
266. 
     
267.                                         mov                dx,800
     
268.                                         jmp                write_256
     
269. 
     
270. 
     
271. 
     
272. pi105:         cmp                bx,105h
     
273.                                         jnz                exit_256
     
274. 
     
275.                                         mov                dx,1024
     
276. 
     
277. write_256:                mov                ax,0a000h
     
278.                                         mov                es,ax
     
279.                                         mov                ax,word ptr [bp+10]
     
280.                                         mul                dx
     
281.                                         add                ax,word ptr [bp+8]
     
282.                                         adc                dl,0
     
283.                                         mov      di,ax
     
284. 
     
285.                                         mov                ax,4f05h
     
286.                                         mov                bx,0
     
287.                                         int                10h
     
288. 
     
289.                                         mov                cl,byte ptr [bp+6]
     
290.                                         mov                byte ptr es:[di],cl
     
291. 
     
292. 
     
293. exit_256:                pop                di
     
294.                                         pop                es
     
295. 
     
296.                                         leavew
     
297.                                         ret
     
298. 
     
299. _Pixel256C                endp
     
300. 
     
301. 
     
302. 
     
303. ;入口参数： ax=要转换的二进制数
     
304. 
     
305. ;出口参数  dx:ax=转换十进数?
     
306. B_O                                proc                near
     
307. 
     
308.                                         enterw          5,0
     
309.                                         push                es
     
310.                                         push                di
     
311.                                         push                si
     
312.                                         mov                bx,10
     
313.                                         mov                cx,5
     
314.                                         mov                di,sp
     
315.                                         mov                ax,ss
     
316.                                         mov                es,ax
     
317. 
     
318. getover:                        div      bx
     
319.                                         add                dl,30h
     
320.                                         mov                byte ptr           es:[di],dl
     
321.                                         dec                cx
     
322.                                         jz                        return
     
323.                                         inc                di
     
324.                                         cmp                ax,0
     
325.                                         jnz      getover
     
326.                                         mov                byte ptr           es:[di],dl
     
327. 
     
328. return:                        xor                dx,dx
     
329.                                         xor                ax,ax
     
330.                                         std
     
331.                                         mov                si,di
     
332. relod:              mov                cx,4
     
333.                                         lodsb
     
334. re:                                shl                dx,1
     
335.                                         shl                ax,1
     
336.                                         jnc                d0
     
337.                                         inc                dx
     
338. d0:                 dec                cx
     
339.                                         jnz                re
     
340. 
     
341.                                         cmp                si,sp
     
342.                                         jnz                relod
     
343. 
     
344.                                         pop                si
     
345.                                         pop                di
     
346.                                         pop                es
     
347.                                         leavew
     
348.                                         ret
     
349. 
     
350. B_O                                endp
     
351. 
     
352. 
     
353. _Demo                 proc                  far
     
354. 
     
355.                                         enterw        0,0
     
356.                                         push                es
     
357.                                         push                di
     
358. 
     
359.                                         mov                ax,0a000h
     
360.                                         mov                es,ax
     
361.                                         mov                dx,1024
     
362.                                         mov                ax,word ptr [bp+12]
     
363.                                         mul                dx
     
364.                                         mov                bx,ax
     
365.                                         mov                cx,dx
     
366.                                         add                ax,bx
     
367.                                         adc                dx,cx
     
368.                                         add                ax,bx
     
369.                                         adc                dx,cx
     
370.                                         add                ax,bx
     
371.                                         adc                dx,cx
     
372. 
     
373.                                         mov                bx,word ptr [bp+10]
     
374.                                         add                bx,word ptr [bp+10]
     
375.                                         add                bx,word ptr [bp+10]
     
376.                                         add                bx,word ptr [bp+10]
     
377.                                         add                ax,bx
     
378.                                         adc                dx,0
     
379. ;                                        cmp                ax,0fffdh
     
380. ;                                        jnbe                exit_Tr
     
381. 
     
382.                                         mov                di,ax
     
383. 
     
384.                                         mov                ax,4f05h
     
385.                                         mov                bx,0
     
386.                                         int                10h
     
387. 
     
388.                                         mov                cx,word ptr [bp+6]
     
389.                                         mov                word ptr es:[di],cx
     
390.                                         add                di,2
     
391.                                         mov                cx,word ptr [bp+8]
     
392.                                         mov                word ptr es:[di],cx
     
393. 
     
394. exit_Tr:                        pop                di
     
395.                                         pop                es
     
396.                                         leavew
     
397. 
     
398.                                         ret
     
399. 
     
400. _Demo                                endp
     
401. 
     
402. 
     
403. _TEXT                         ends
     
404. 
     
405. 
     
406. 
     
407. 
     
408. _DATA                                segment  use16        byte public 'data'
     
409. 
     
410. c@                                        label                byte
     
411.                                         db                        37
     
412.                                         db                        63h
     
413.                                         db                        10
     
414.                                         db                        0
     
415. 
     
416. s@                                        label                byte
     
417.                                         db                        37
     
418.                                         db                        73h
     
419.                                         db                        10
     
420.                                         db                        0
     
421. 
     
422. d@                                        label                byte
     
423.                                         db                        37
     
424.                                         db                        64h
     
425.                                         db                        10
     
426.                                         db                        0
     
427. 
     
428. x@                                        label                byte
     
429.                                         db                        37
     
430.                                         db                        78h
     
431.                                         db                        10
     
432.                                         db                        0
     
433. 
     
434. u@                                        label                byte
     
435.                                         db                        37
     
436.                                         db                        75h
     
437.                                         db                        10
     
438.                                         db                        0
     
439. 
     
440. o@                                        label                byte
     
441.                                         db                        37
     
442.                                         db                        6fh
     
443.                                         db                        10
     
444.                                         db                        0
     
445. 
     
446. 
     
447. _DATA               ends
     
448. 
     
449. 
     
450. 
     
451. 
     
452. _BSS                                segment        use16        byte public 'data'
     
453. 
     
454. attr                                _ATTRI        ?
     
455.                                         db                        0f0h dup(0)
     
456. 
     
457. _BSS                                ends
     
458. 
     
459. 
     
460.                                         end
     

复制代码

arenxl

看不懂啊！！

bierdaci

其实挺挺简单的，你可以不用看汇编写的画点函数，因为涉及到VESA图形接口，得知道VESA BIOS的功能调用还要稍微理解硬件分页映射寄存器的工作原理，如果手头没有这样的书就不用管画点函数了，我当时也是看了一本X86汇编语言程序设计，里边简要的介绍了这部分内容，就编了这么个小程序。除了画点函数程序就非常简单了，就想没必要写上注释，不过可以发到这里有点乱我把几个宏和函数的功能简单的说一下

void init(int);

函数功能：初使化显示模式
参数：Hi800_600 高彩色800*600分辨率、 Tr800_600 真彩色800*600分辨率、Hi1024_768、Tr1024_768

void Pixel16HiC(color,x,y);
函数功能：画16位高位彩色点
参数：color 颜色值，x 轴坐标，y 轴坐标
void Pixel24TrC(color,x,y);
同上

宏Trc(R,G,B)
功能：把红、绿、蓝转换成24位颜色值

struct bmp_head 取是BMP位图的长、宽和颜色等信息

其它的就自己看看吧，程序挺简单的本来是想编个能打开JPG格式图片程序，还有想在保护模式下实现，后来因为找不到JPG格式的资料，还有在保护模式下太麻烦，也就是想编着玩没想在这上面浪费太多的精力。程序打开图片的速度很慢，而且只是简单的打开BMP图片没有实现任何功能，如果能找到硬件加速的资料我想肯定能快多了。有兴趣的可以编译着试试，另外虽然我用的是24位真彩色模式但我是在TNT2显卡下写的画点函数，因为NVIDIA用的32位寄存器（我也不知道多出那8位有什么用，当时多出的这8位让我很痛苦，用24位寄存器画点老是不对，后来我就编了几个宏才测出来我的TNT2用的是32位寄存器），所以其它显卡可能不好使不过只要Nvidia系列的应该都好用，我在Gforce系列的试过也都好用。

lenovo

你用code功能把你的代码编辑一下吧。
这样看着舒服些。

JohnBull

好亲切!
以前也写过,可是写的没楼主好.输出用的是pattern画线.

w25

我以前看过清华出的那本计算机图形学的书，本来想奔那方面发展，但是老师看不上我，我也就只好改行了。哈哈

阿辉

记得读书的时候我还用C写过一个小游戏，是小飞机的那种，C内有一个函数可以截屏的，然后再内容放在内存中，然再清除，然后再COPY，呵呵，飞机就是这样走动的。。。

想想，毕业后就很少玩C了。唉。。。

mzpvsww

呵呵，弓虽？我用c ，不过对汇编就垃圾的很

bierdaci

呵呵，那时我编了一个类似DOS的EDIT ，不过是先看了别人的源码再去编的，那时我当时在DOS下编的最大的一个程序，好像是1000多行，不过我用C编的第一个程序是数学表达式的计算，支持加、减、乘、除、括号、等号还有正弦余弦运算，比如输入表达式运算2*（3+5）=然后回车就可以计算出结果，这是我当时学C时编的的第一个非常有成就的程序，为了这个程序我画了整整一大张的流程图，而且时间基本上都是花在画流程图上了，等到写程序的时候基本没有费多大劲，甚至连调试都很少，运行的还很成功，当时的成就感心里那个美啊，现在想起来还……说不出那个心情。那时编的小程序很多，后来学汇编的时候也编过不少小程序，可惜因为硬盘坏了东西全没了，要不我肯定会把我的那个数学表达式的程序给贴上来，虽然那个程序现在看来很幼稚很简单但因为那是我编的第一个程序而且那时没有看过任何程序的源码，所有思路全是自己想出来的，所以很想贴上来给你们看看.上面这个程序是在我学准备学LINUX之前编写的，因为那时实在不知道自己该学什么，在徘徊中时编了这么一个程序解闷，现在手里就这么一个程序了所以就把这个程序给贴了上来

mzpvsww

呵呵，计数器的程序也是我在学的间断的一个重要的程序，当时好象写了近1200行，