radiance32 wrote on 2024-05-03, 02:57:

But, I've tried everything I can think of, and I just can't figure out the layout of the memory.

CGA screen buffer in monochrome mode starts at B800:0000 and is 640x200 pixels, with 8 pixels to a byte. The mode is interlaced; the first 8KB half of screen memory are the even lines and the second 8KB half are the odd lines.

long videobuf_size = _imagesize( 0, 0, width-1, height-1 ); // This value turns out to be 16006 (CGA HIRES mode requires 16KB so that makes sense, what the additional 6 are I don't know..

Post the source code of _imagesize, and what width and height are, otherwise we can't help you.

# Clear the buffer for(int i=0; i<videobuf_size; i++) { videobuf = 0; } […]
Show full quote

# Clear the buffer
for(int i=0; i<videobuf_size; i++) {
videobuf = 0;
}

memset() is much faster; use that.

# Once it's finished, I copy the buffer from memory to graphics memory to display it: _putimage( 0, 0, videobuf, _GPSET ); I […]
Show full quote

# Once it's finished, I copy the buffer from memory to graphics memory to display it:

_putimage( 0, 0, videobuf, _GPSET );


IMO this should work, but, as you can see in the attached image, the whole thing is a mess of vertical lines.

Post the source code of _putimage and what _GPSET is. Better yet, if you truly have a full buffer in system RAM, just use memcpy().

Moderator: Does VOGONs have a dedicated programming forum?

MobyGamer wrote on 2024-05-03, 03:24:

CGA screen buffer in monochrome mode starts at B800:0000 and is 640x200 pixels, with 8 pixels to a byte. The mode is interlaced […]
Show full quote

radiance32 wrote on 2024-05-03, 02:57:

But, I've tried everything I can think of, and I just can't figure out the layout of the memory.

CGA screen buffer in monochrome mode starts at B800:0000 and is 640x200 pixels, with 8 pixels to a byte. The mode is interlaced; the first 8KB half of screen memory are the even lines and the second 8KB half are the odd lines.

long videobuf_size = _imagesize( 0, 0, width-1, height-1 ); // This value turns out to be 16006 (CGA HIRES mode requires 16KB so that makes sense, what the additional 6 are I don't know..

Post the source code of _imagesize, and what width and height are, otherwise we can't help you.

# Clear the buffer for(int i=0; i<videobuf_size; i++) { videobuf = 0; } […]
Show full quote

# Clear the buffer
for(int i=0; i<videobuf_size; i++) {
videobuf = 0;
}

memset() is much faster; use that.

# Once it's finished, I copy the buffer from memory to graphics memory to display it: _putimage( 0, 0, videobuf, _GPSET ); I […]
Show full quote

# Once it's finished, I copy the buffer from memory to graphics memory to display it:

_putimage( 0, 0, videobuf, _GPSET );


IMO this should work, but, as you can see in the attached image, the whole thing is a mess of vertical lines.

Post the source code of _putimage and what _GPSET is. Better yet, if you truly have a full buffer in system RAM, just use memcpy().

Moderator: Does VOGONs have a dedicated programming forum?

Hi,

_putimage() is a function of the Watcom graph.h library.

#include <graph.h>
void _FAR _putimage( short x, short y,
char _HUGE *image, short mode );

Link to Documentation: https://open-watcom.github.io/open-watcom-v2- … .html#_putimage
The docs don't mention any formats etc..

There is also a _getimage() which does the opposite.
And the _imagesize() is also a Watcom graph.h function that returns the size of the coordinates given.

As for width = 640 and height = 200

_GPSET tells putimage() to copy the bits (eg no AND/ORs on the pixels etc...)

It would be really handy if you or someone else could provide some example C/C++ code as I am a Visual Learner and am not used to working with hex addresses etc...
I already read that CGA is interlaced, but I was hoping the Watcom graph.h _getimage and _putimage functions translate this for you... (maybe they do not, i'm not sure, documentation is abysmal and google searches yield few results if any)

Thanks!,
Terrence

PS: memset() thanks for the tip... It's been more than a decade since I've used it 😀

I can't provide watcom support, sorry. Maybe someone else can, either here or at VCFED forums.

To understand CGA, I would suggest writing a small program that sets the graphics mode, then writes a byte of 0xFF to a pointer set to the address B800:0000. You will see 8 pixels show up in the upper left corner, on line 0. Then write these values:
Write 0xFF to 0xB800:0x0050: You will see another 8 pixels show up in the upper left corner, but this time two lines down on line 2, because CGA's first 8KB covers only the even lines.
Write 0x55 to 0xB800:0x2000: You will see 8 *alternating* pixels show up in the upper left corner, but inbetween the others, on line 1, because you are now writing in the second 8KB "bank" of CGA memory which covers the odd lines.

MobyGamer wrote on 2024-05-03, 03:39:

I can't provide watcom support, sorry. Maybe someone else can, either here or at VCFED forums. […]
Show full quote

I can't provide watcom support, sorry. Maybe someone else can, either here or at VCFED forums.

To understand CGA, I would suggest writing a small program that sets the graphics mode, then writes a byte of 0xFF to a pointer set to the address B800:0000. You will see 8 pixels show up in the upper left corner, on line 0. Then write these values:
Write 0xFF to 0xB800:0x0050: You will see another 8 pixels show up in the upper left corner, but this time two lines down on line 2, because CGA's first 8KB covers only the even lines.
Write 0x55 to 0xB800:0x2000: You will see 8 *alternating* pixels show up in the upper left corner, but inbetween the others, on line 1, because you are now writing in the second 8KB "bank" of CGA memory which covers the odd lines.

You wouldn't happen to have any C/C++ code lying around or that you know of that directly addresses a CGA adapter like this ?

Thanks,
Terrence

you cant just cast a byte array to bool, and address it the way you do, its still a byte array underneath, not bits which is what cga is expecting (so bitbuf[( y * (width-1) ) + x] = true; wont do what you think its doing). you want to be doing bitwise ops with actual bits, not true + false on bytes. thats why your image is all dots with spaces, none of your bits are consecutive.

Can someone provide me with a simple example function in C/C++ on how to set an individual CGA pixel in an offscreen buffer like this one:

char *videobuf;
videobuf = (char*) malloc (0x4000); // 16384 bytes

eg I need a cheap/fast "setpixel(videobuf, x, y)"
Hopefully without having to read the entire char first, as I need as much speed as I can get...

Cheers,
Terrence

BloodyCactus wrote on 2024-05-03, 04:06:

you cant just cast a byte array to bool, and address it the way you do, its still a byte array underneath, not bits which is what cga is expecting (so bitbuf[( y * (width-1) ) + x] = true; wont do what you think its doing). you want to be doing bitwise ops with actual bits, not true + false on bytes. thats why your image is all dots with spaces, none of your bits are consecutive.

Yeah, I figured that out not too long ago 😀

Terrence

Not sure if this is a 100% correct. I am sure some smart person here can point out bugs but it will give you at least some bare-bone Watcom based example without using libraries. [sorry, I do not have much time, just whipping this up while I am waiting for my wife to get ready as we're about to go out].

1#include <i86.h>   // int86x
2#include <conio.h> // kbhit, getch
3
4#define SCREEN_WIDTH   640
5#define SCREEN_HEIGHT  200
6
7void mode_set(unsigned char mode)
8{
9  union REGS regs;
10  struct SREGS sregs;
11
12  regs.h.al = mode;
13  regs.h.ah = 0;
14
15  int86x(0x10, &regs, &regs, &sregs);
16}
17
18void pixel_set(int x, int y)
19{
20  unsigned char far *video;
21  int offset;
22
23  if (y % 2) {
24    video = (unsigned char far*)0xb8000000L;
25  }
26  else {
27    video = (unsigned char far*)0xb8002000L;
28  }
29
30  // Calculate the offset of the byte in which we need to store the pixel.
31  offset = ((y / 2) * (SCREEN_WIDTH / 8)) + (x / 8);
32
33  // Then read that byte, OR in the pixel at the right position, and write the byte back.
34  *(video + offset) = *(video + offset) | (0x80 >> (x & 7));
35}
36
37void main()
38{
39  // Set graphics mode 640 x 200
40  mode_set(6);
41
42  pixel_set(50, 50);
43
44  while(1) {
45    if (kbhit()) {
46      int key = getch();
47
48      // 27 = ESC key
49      if (key == 27) {
50        break;
51      }
52    }
53  }
54
55  // Set graphics mode 640 x 200
56  mode_set(3); 
57}

Compile with (assuming you're saving the code in main.c):

1wcc -zq -2 -bt=dos main.c -i$WATCOM/h
2wlink option quiet sys dos name main.exe file main.o libpath $WATCOM/lib286:$WATCOM/lib286/dos

You have to make sure that the $WATCOM environment variable is set to your Watcom directory. For me on Linux it's set to

1/usr/bin/watcom

Hope this helps.

Hi,

FIrst of all a big thanks for writing this for me, it's highly appreciated! 😀

I tried it out, and it works, but, there are some interleaving artifacts,
check out the attached screenshot...

Any idea what that might be and h0w to fix it ?

Cheers,
Terrence

pan069 wrote on 2024-05-03, 08:21:

Not sure if this is a 100% correct. I am sure some smart person here can point out bugs but it will give you at least some bare- […]
Show full quote

Not sure if this is a 100% correct. I am sure some smart person here can point out bugs but it will give you at least some bare-bone Watcom based example without using libraries. [sorry, I do not have much time, just whipping this up while I am waiting for my wife to get ready as we're about to go out].

Copy code to clipboard

1#include <i86.h>   // int86x
2#include <conio.h> // kbhit, getch
3
4#define SCREEN_WIDTH   640
5#define SCREEN_HEIGHT  200
6
7void mode_set(unsigned char mode)
8{
9  union REGS regs;
10  struct SREGS sregs;
11
12  regs.h.al = mode;
13  regs.h.ah = 0;
14
15  int86x(0x10, &regs, &regs, &sregs);
16}
17
18void pixel_set(int x, int y)
19{
20  unsigned char far *video;
21  int offset;
22
23  if (y % 2) {
24    video = (unsigned char far*)0xb8000000L;
25  }
26  else {
27    video = (unsigned char far*)0xb8002000L;
28  }
29
30  // Calculate the offset of the byte in which we need to store the pixel.
31  offset = ((y / 2) * (SCREEN_WIDTH / 8)) + (x / 8);
32
33  // Then read that byte, OR in the pixel at the right position, and write the byte back.
34  *(video + offset) = *(video + offset) | (0x80 >> (x & 7));
35}
36
37void main()
38{
39  // Set graphics mode 640 x 200
40  mode_set(6);
41
42  pixel_set(50, 50);
43
44  while(1) {
45    if (kbhit()) {
46      int key = getch();
47
48      // 27 = ESC key
49      if (key == 27) {
50        break;
51      }
52    }
53  }
54
55  // Set graphics mode 640 x 200
56  mode_set(3); 
57}

Compile with (assuming you're saving the code in main.c):

Copy code to clipboard

1wcc -zq -2 -bt=dos main.c -i$WATCOM/h
2wlink option quiet sys dos name main.exe file main.o libpath $WATCOM/lib286:$WATCOM/lib286/dos

You have to make sure that the $WATCOM environment variable is set to your Watcom directory. For me on Linux it's set to

Copy code to clipboard

1/usr/bin/watcom

Hope this helps.

radiance32 wrote on 2024-05-03, 22:16:

Hi, […]
Show full quote

Hi,

FIrst of all a big thanks for writing this for me, it's highly appreciated! 😀

I tried it out, and it works, but, there are some interleaving artifacts,
check out the attached screenshot...

Any idea what that might be and h0w to fix it ?

No worries. Yeah, I was expecting my code to have some issues. Can you share your code so we can have a closer look?

Here's my pixel and line drawing functions (line does not use DrawCGAPoint, it has the code already in it):
Sharing the complete source would not be needed and it's a LOT of code... here's what's important:

1void DrawCGAPoint (char *videobuf, int &videowidth, int &videoheight, int x, int y) {
2        unsigned char far *video;
3        if (y % 2) video = (unsigned char far*) &videobuf[0]; 
4        else video = (unsigned char far*) &videobuf[8192];
5                        
6        int offset = ((y / 2) * (videowidth / 8)) + (x / 8);
7        *(video + offset) = *(video + offset) | (0x80 >> (x & 7));        
8};
9
10// THE EXTREMELY FAST LINE ALGORITHM Variation D (Addition Fixed Point)
11void DrawCGALine(char *videobuf, int &videowidth, int &videoheight, int x, int y, int x2, int y2) {
12        bool yLonger = false;
13        int incrementVal, endVal;
14        int shortLen = y2 - y;
15        int longLen = x2 - x;
16        if (abs(shortLen) > abs(longLen)) {
17                int swap = shortLen;
18                shortLen = longLen;
19                longLen = swap;
20                yLonger = true;
21        }
22        endVal = longLen;
23        if (longLen < 0) {
24                incrementVal = -1;
25                longLen = -longLen;
26        }
27        else incrementVal = 1;
28        int decInc;
29        if (longLen == 0) decInc = 0;
30        else decInc = (shortLen << 8) / longLen;
31        int j = 0;
32        if (yLonger) {
33                for (int i = 0; i != endVal; i += incrementVal) {
34#if defined (__WINDOWS)
35                        SETPIXEL(x + (j >> 8), y + i, 15);
36#elif defined (__WATCOM)
37                        int xx = x + (j >> 8);
38                        int yy = y + i;
39                        
40                        unsigned char far *video;
41                        if (yy % 2) video = (unsigned char far*) &videobuf[0]; 
42                        else video = (unsigned char far*) &videobuf[8192];
43                        
44                        int offset = ((yy / 2) * (videowidth / 8)) + (xx / 8);
45                        *(video + offset) = *(video + offset) | (0x80 >> (xx & 7));
46#endif
47                        j += decInc;
48                }
49        }
50        else {
51                for (int i = 0; i != endVal; i += incrementVal) {
52#if defined (__WINDOWS)
53                        SETPIXEL(x + i, y + (j >> 8), 15);
54#elif defined (__WATCOM)
55                        int xx = x + i;
56                        int yy = y + (j >> 8);
57                        
58                        unsigned char far *video;
59                        if (yy % 2) video = (unsigned char far*) &videobuf[0]; 
60                        else video = (unsigned char far*) &videobuf[8192];

61                        
62                        int offset = ((yy / 2) * (videowidth / 8)) + (xx / 8);
63                        *(video + offset) = *(video + offset) | (0x80 >> (xx & 7));
64#endif
65                        j += decInc;
66                }
67        }
68};

The rest below is just how I create, zero out and copy my memory buffer that I am drawing my lines in:

1 // Allocate main memory screen buffer
2 int videobuf_size = 16384;
3 char *videobuf = (char*) malloc (0x4000); // 16384 bytes
4
5Render loop does:
6
7 // Clear Screen Buffer
8memset(videobuf, 0, 16384); 
9
10// Transform triangles
11// Draw triangles as 3 lines with the above drawing function DrawCGALine(...)
12
13 // Copy videobuf to CGA adapter video memory
14memcpy (vbufCGA, videobuf, 0x4000);

That's all of relevance (I think)

Anyways, I works, but there's some interlacing bug going on, as you can see in the image I attached to my previous post of the XYZ axis 3D object...

Cheers,
Terrence
...

// Copy videobuf to CGA adapter video memory
memcpy (vbufCGA, videobuf, 0x4000);

pan069 wrote on 2024-05-03, 22:51:

radiance32 wrote on 2024-05-03, 22:16:

Hi, […]
Show full quote

Hi,

FIrst of all a big thanks for writing this for me, it's highly appreciated! 😀

I tried it out, and it works, but, there are some interleaving artifacts,
check out the attached screenshot...

Any idea what that might be and h0w to fix it ?

No worries. Yeah, I was expecting my code to have some issues. Can you share your code so we can have a closer look?

Hi.

Sorry, I couldn't get your line code to work so I made a new version of my previous code example. This version uses an off-screen memory buffer, draws a line (just a crappy implementation just for demo purposes), and then copies the buffer to the screen.

I made the off-screen buffer a linear buffer, this makes it much easier to work with in terms of plotting pixels etc. Only when the off-screen buffer is copied to the screen it takes the interleaved nature of the CGA video memory into account and copies an even scanline, then an odd scanline etc. until all scanlines in the off-screen buffer have been copied.

I hope this demonstrates that the pixel plotting works correctly and the copying of the off-screen buffer.

1#include <i86.h>     // int86x
2#include <conio.h>   // kbhit, getch
3#include <malloc.h>  // _fmalloc, _ffree
4#include <string.h>  // _fmemcpy, _fmemset
5
6#define SCREEN_WIDTH   640
7#define SCREEN_HEIGHT  200
8
9void mode_set(unsigned char mode)
10{
11  union REGS regs;
12  struct SREGS sregs;
13
14  regs.h.al = mode;
15  regs.h.ah = 0;
16
17  int86x(0x10, &regs, &regs, &sregs);
18}
19
20void pixel_set(unsigned char far* buffer, int x, int y)
21{
22  // Calculate the offset of the byte in which we need to store the pixel.
23  int offset = (y * (SCREEN_WIDTH / 8)) + (x >> 3);
24
25  // Add the pixel byte offset to the back buffer address (offset within the buffer).
26  buffer += offset;
27
28  // Read the buffer byte and shift the pixel bit into the right position and OR together
29  *buffer |= (0x80 >> (x & 7));
30}
31
32void back_buffer_clear(unsigned char far* buffer)
33{
34  _fmemset(buffer, 0, sizeof(char) * ((SCREEN_WIDTH / 8) * SCREEN_HEIGHT));
35}
36
37void back_buffer_copy(unsigned char far* buffer)
38{
39  int y;
40
41  // Have two pointers, one points to the start of the even scan lines
42  // the other points to the start of the odd scan lines.
43  unsigned char far* video_even = (unsigned char far*)0xb8000000L;
44  unsigned char far* video_odd  = (unsigned char far*)0xb8002000L;
45
46  // Copy the buffer to video memory by alternating each scanline. First
47  // copy a scan line to even video memory, then the next to odd video memory.
48  for (y = 0; y < SCREEN_HEIGHT / 2; y++) {
49    _fmemcpy(video_even, buffer, SCREEN_WIDTH / 8);
50
51    video_even += SCREEN_WIDTH / 8;
52    buffer += SCREEN_WIDTH / 8;
53
54    _fmemcpy(video_odd, buffer, SCREEN_WIDTH / 8);
55
56    video_odd += SCREEN_WIDTH / 8;
57    buffer += SCREEN_WIDTH / 8;
58  }
59}
60

61// NOTE: Only draws lines from top-left to bottom-right!
62void line(unsigned char far* buffer, int src_x, int src_y, int tgt_x, int tgt_y)
63{
64  int diff_x = (tgt_x - src_x);
65  int diff_y = (tgt_y - src_y);
66  int err = 0;
67  int x = src_x;
68  int y = src_y;
69
70  while (x < tgt_x) {
71    pixel_set(buffer, x, y);
72
73    err = err + diff_y;
74
75    if (err >= diff_x) {
76      y++;
77      err = err - diff_x;
78    }
79
80    x++;
81  }
82}
83
84void main()
85{
86  // Allocate the back buffer
87  unsigned char far* buffer = _fmalloc(sizeof(char) * ((SCREEN_WIDTH / 8) * SCREEN_HEIGHT));
88
89  // Set graphics mode 640 x 200 (1 bpp)
90  mode_set(6);
91
92  // Clear the back buffer.
93  back_buffer_clear(buffer);
94
95  // Draw line from top-left to bottom-right.
96  line(buffer, 0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1);
97
98  // Copy back buffer to the screen
99  back_buffer_copy(buffer);
100
101  // Loop indefinitely until ESC
102  while(1) {
103    if (kbhit()) {
104      int key = getch();
105
106      // 27 = ESC key
107      if (key == 27) {
108        break;
109      }
110    }
111  }
112
113  // Set text mode
114  mode_set(3); 
115
116  // Release back buffer
117  _ffree(buffer);
118}

To compile use the same command I showed earlier.

Good luck!

PS: Source of the line drawing algo I used: https://www.it.uu.se/edu/course/homepage/graf … gon/x_lines.htm

I remember always being confused about whether the least significant bit is the left-most pixel of the 8-pixel run or the right-most one. Apparently it’s the latter…

Wow thanks for all this work 😀
It's truly appreciated 😀

I'm gonna have a coffee, wake up and then have a try at blendering your code into my 3D rasterizer 😀
I'll report on the results here...

Thanks again!,
Terrence

pan069 wrote on 2024-05-04, 08:11:

Hi. […]
Show full quote

Hi.

Sorry, I couldn't get your line code to work so I made a new version of my previous code example. This version uses an off-screen memory buffer, draws a line (just a crappy implementation just for demo purposes), and then copies the buffer to the screen.

I made the off-screen buffer a linear buffer, this makes it much easier to work with in terms of plotting pixels etc. Only when the off-screen buffer is copied to the screen it takes the interleaved nature of the CGA video memory into account and copies an even scanline, then an odd scanline etc. until all scanlines in the off-screen buffer have been copied.

I hope this demonstrates that the pixel plotting works correctly and the copying of the off-screen buffer.

Copy code to clipboard

1#include <i86.h>     // int86x
2#include <conio.h>   // kbhit, getch
3#include <malloc.h>  // _fmalloc, _ffree
4#include <string.h>  // _fmemcpy, _fmemset
5
6#define SCREEN_WIDTH   640
7#define SCREEN_HEIGHT  200
8
9void mode_set(unsigned char mode)
10{
11  union REGS regs;
12  struct SREGS sregs;
13
14  regs.h.al = mode;
15  regs.h.ah = 0;
16
17  int86x(0x10, &regs, &regs, &sregs);
18}
19
20void pixel_set(unsigned char far* buffer, int x, int y)
21{
22  // Calculate the offset of the byte in which we need to store the pixel.
23  int offset = (y * (SCREEN_WIDTH / 8)) + (x >> 3);
24
25  // Add the pixel byte offset to the back buffer address (offset within the buffer).
26  buffer += offset;
27
28  // Read the buffer byte and shift the pixel bit into the right position and OR together
29  *buffer |= (0x80 >> (x & 7));
30}
31
32void back_buffer_clear(unsigned char far* buffer)
33{
34  _fmemset(buffer, 0, sizeof(char) * ((SCREEN_WIDTH / 8) * SCREEN_HEIGHT));
35}
36
37void back_buffer_copy(unsigned char far* buffer)
38{
39  int y;
40
41  // Have two pointers, one points to the start of the even scan lines
42  // the other points to the start of the odd scan lines.
43  unsigned char far* video_even = (unsigned char far*)0xb8000000L;
44  unsigned char far* video_odd  = (unsigned char far*)0xb8002000L;
45
46  // Copy the buffer to video memory by alternating each scanline. First
47  // copy a scan line to even video memory, then the next to odd video memory.
48  for (y = 0; y < SCREEN_HEIGHT / 2; y++) {
49    _fmemcpy(video_even, buffer, SCREEN_WIDTH / 8);
50
51    video_even += SCREEN_WIDTH / 8;
52    buffer += SCREEN_WIDTH / 8;
53
54    _fmemcpy(video_odd, buffer, SCREEN_WIDTH / 8);
55
56    video_odd += SCREEN_WIDTH / 8;
57    buffer += SCREEN_WIDTH / 8;
58  }
59}
60

…Show last 59 lines

61// NOTE: Only draws lines from top-left to bottom-right!
62void line(unsigned char far* buffer, int src_x, int src_y, int tgt_x, int tgt_y)
63{
64  int diff_x = (tgt_x - src_x);
65  int diff_y = (tgt_y - src_y);
66  int err = 0;
67  int x = src_x;
68  int y = src_y;
69
70  while (x < tgt_x) {
71    pixel_set(buffer, x, y);
72
73    err = err + diff_y;
74
75    if (err >= diff_x) {
76      y++;
77      err = err - diff_x;
78    }
79
80    x++;
81  }
82}
83
84void main()
85{
86  // Allocate the back buffer
87  unsigned char far* buffer = _fmalloc(sizeof(char) * ((SCREEN_WIDTH / 8) * SCREEN_HEIGHT));
88
89  // Set graphics mode 640 x 200 (1 bpp)
90  mode_set(6);
91
92  // Clear the back buffer.
93  back_buffer_clear(buffer);
94
95  // Draw line from top-left to bottom-right.
96  line(buffer, 0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1);
97
98  // Copy back buffer to the screen
99  back_buffer_copy(buffer);
100
101  // Loop indefinitely until ESC
102  while(1) {
103    if (kbhit()) {
104      int key = getch();
105
106      // 27 = ESC key
107      if (key == 27) {
108        break;
109      }
110    }
111  }
112
113  // Set text mode
114  mode_set(3); 
115
116  // Release back buffer
117  _ffree(buffer);
118}

To compile use the same command I showed earlier.

Good luck!

PS: Source of the line drawing algo I used: https://www.it.uu.se/edu/course/homepage/graf … gon/x_lines.htm

Great, It works %100 now 😀

See the attached image of suzanne (the blender monkey primitive) 😀
It's got approx 450 polygons and I'm getting about 3 FPS on a 80186 @ 16MHz (My 200LX palmtop with doublespeed crystal installed)

I've still many things to optimize, such as transforming every float uses in the render loop to fixed point integers,
and I can also shave off one or two matrix transforms by combining them.

When I'm finished and I've got my C/C++ prototype fully optimized,
then I'm gonna tackle further optimization by reprogramming render loop operations into 8086 assembly code,
but that's still far away at the moment...

Thanks again for your help,
I've always programmed 3D graphics stuff for modern x64 and Nvidia CUDA targets in Visual Studio or using GCC and Clang on linux/MacOSX,
this is my first time developing a C/C++ app for 16bit DOS. I'm learning about memory models, far and huge memory addressing etc...

Big thanks! 😀
Terrence

pan069 wrote on 2024-05-04, 08:11:

Hi. […]
Show full quote

Hi.

Sorry, I couldn't get your line code to work so I made a new version of my previous code example. This version uses an off-screen memory buffer, draws a line (just a crappy implementation just for demo purposes), and then copies the buffer to the screen.

I made the off-screen buffer a linear buffer, this makes it much easier to work with in terms of plotting pixels etc. Only when the off-screen buffer is copied to the screen it takes the interleaved nature of the CGA video memory into account and copies an even scanline, then an odd scanline etc. until all scanlines in the off-screen buffer have been copied.

I hope this demonstrates that the pixel plotting works correctly and the copying of the off-screen buffer.

Copy code to clipboard

1#include <i86.h>     // int86x
2#include <conio.h>   // kbhit, getch
3#include <malloc.h>  // _fmalloc, _ffree
4#include <string.h>  // _fmemcpy, _fmemset
5
6#define SCREEN_WIDTH   640
7#define SCREEN_HEIGHT  200
8
9void mode_set(unsigned char mode)
10{
11  union REGS regs;
12  struct SREGS sregs;
13
14  regs.h.al = mode;
15  regs.h.ah = 0;
16
17  int86x(0x10, &regs, &regs, &sregs);
18}
19
20void pixel_set(unsigned char far* buffer, int x, int y)
21{
22  // Calculate the offset of the byte in which we need to store the pixel.
23  int offset = (y * (SCREEN_WIDTH / 8)) + (x >> 3);
24
25  // Add the pixel byte offset to the back buffer address (offset within the buffer).
26  buffer += offset;
27
28  // Read the buffer byte and shift the pixel bit into the right position and OR together
29  *buffer |= (0x80 >> (x & 7));
30}
31
32void back_buffer_clear(unsigned char far* buffer)
33{
34  _fmemset(buffer, 0, sizeof(char) * ((SCREEN_WIDTH / 8) * SCREEN_HEIGHT));
35}
36
37void back_buffer_copy(unsigned char far* buffer)
38{
39  int y;
40
41  // Have two pointers, one points to the start of the even scan lines
42  // the other points to the start of the odd scan lines.
43  unsigned char far* video_even = (unsigned char far*)0xb8000000L;
44  unsigned char far* video_odd  = (unsigned char far*)0xb8002000L;
45
46  // Copy the buffer to video memory by alternating each scanline. First
47  // copy a scan line to even video memory, then the next to odd video memory.
48  for (y = 0; y < SCREEN_HEIGHT / 2; y++) {
49    _fmemcpy(video_even, buffer, SCREEN_WIDTH / 8);
50
51    video_even += SCREEN_WIDTH / 8;
52    buffer += SCREEN_WIDTH / 8;
53
54    _fmemcpy(video_odd, buffer, SCREEN_WIDTH / 8);
55
56    video_odd += SCREEN_WIDTH / 8;
57    buffer += SCREEN_WIDTH / 8;
58  }
59}
60

…Show last 59 lines

61// NOTE: Only draws lines from top-left to bottom-right!
62void line(unsigned char far* buffer, int src_x, int src_y, int tgt_x, int tgt_y)
63{
64  int diff_x = (tgt_x - src_x);
65  int diff_y = (tgt_y - src_y);
66  int err = 0;
67  int x = src_x;
68  int y = src_y;
69
70  while (x < tgt_x) {
71    pixel_set(buffer, x, y);
72
73    err = err + diff_y;
74
75    if (err >= diff_x) {
76      y++;
77      err = err - diff_x;
78    }
79
80    x++;
81  }
82}
83
84void main()
85{
86  // Allocate the back buffer
87  unsigned char far* buffer = _fmalloc(sizeof(char) * ((SCREEN_WIDTH / 8) * SCREEN_HEIGHT));
88
89  // Set graphics mode 640 x 200 (1 bpp)
90  mode_set(6);
91
92  // Clear the back buffer.
93  back_buffer_clear(buffer);
94
95  // Draw line from top-left to bottom-right.
96  line(buffer, 0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1);
97
98  // Copy back buffer to the screen
99  back_buffer_copy(buffer);
100
101  // Loop indefinitely until ESC
102  while(1) {
103    if (kbhit()) {
104      int key = getch();
105
106      // 27 = ESC key
107      if (key == 27) {
108        break;
109      }
110    }
111  }
112
113  // Set text mode
114  mode_set(3); 
115
116  // Release back buffer
117  _ffree(buffer);
118}

To compile use the same command I showed earlier.

Good luck!

PS: Source of the line drawing algo I used: https://www.it.uu.se/edu/course/homepage/graf … gon/x_lines.htm

radiance32 wrote on 2024-05-04, 23:07:

Great, It works %100 now 😀

Fantastic! Glad it works. The screen shot looks great. Good luck with your project!

pan069 wrote on 2024-05-04, 23:29:

radiance32 wrote on 2024-05-04, 23:07:

Great, It works %100 now 😀

Fantastic! Glad it works. The screen shot looks great. Good luck with your project!

Thanks again 😀

Another question,
I'm developing this for my 200LX, which has a very wide screen,
so the 640x200 mono CGA mode has square pixels on it's LCD,
but, on a PC monitor, this mode is displayed streched out vertically,
eg one pixel is two pixels vertically.

Since I''m using DOSBOX to test everything while I develop,
is it possible to configure DOSBOX to use an alternative aspect ratio,
so I can run my CGA HIRES app in DOSBOX with square pixels on a wide screen ?

I've searched through the DOSBOX configuration options and can't find anything...

Cheers,
Terrence

I don't know much about DOSBox. But there is a dedicated DOSBox section on Vogons, maybe best to start a new thread there?

DOSBox