The indigoparadox Web Zone

1. Introduction

This project might be a real head-scratcher, even for those normally willing to extend the benefit of the doubt to knowledge for knowledge's sake. It seems fairly common for folks to dig out their old childhood computers these days and look at them with new eyes. Less common, however, seems to be the impulse to dig out one's old childhood programming languages.

But we wanted a change of pace, and we do what we want! So here it is. A combination of a language we haven't touched in around 20 years with our most recent interest: OpenGL 1.0.

This is not an exhaustive tutorial. Putting together basic knowledge of Visual Basic with declare() statements and knowledge of the quirks below and the information from the tutorial linked in the previous paragraph should be enough to reproduce these results if one is so inclined.

This is merely a collection of notes and observations. With that out of the way...

2. Visual Basic Basics

We said this is not a tutorial, but Visual Basic is not difficult to pick up in a hurry if you're already familiar with programming. With that in mind, and because it's not exactly a popular language, these days, here are some basics for getting started:

• Declare variables with Dim x as type. Types are Integer (16-bit), Long (32-bit), Single (32-bit floating point), Double (64-bit floating point), Boolean (boolean), and String, which is variable length (although you can fix its length by declaring it as e.g. String * 1 for 1-length, which is also how you might declare a byte, since there's no Char!)
• Procedures can either be a Function (returns a value) or a Sub (does not return a value). Generally, you don't use parentheses to surround arguments when calling either, unless you're assigning the return value of a Function, in which case you do!
• You can call procedures from external libraries (DLL files) using the syntax: Declare Procedure_Name Lib "Library_Name (sans .DLL)" (Arguments) As Return_Type, replacing Procedure_Name, Library_Name (sans .DLL), Arguments, and Return_Type as appropriate to match the procedure's signature. If you get this wrong, VB will throw an Invalid Calling Convention error!

3. Visual Basic Quirks

A not-insignificant part of this project was re-learning Visual Basic 4. This was complicated by a factor somewhat common to learning all obsolete APIs and programming languages: there are newer versions out there. Some things that will work in Visual Basic 5 or 6 will not work in Visual Basic 4. VB.net is basically a completely different language. All of these seem to be much more popular than Visual Basic 4, specifically.

Below is a list of things to keep in mind using Visual Basic 4, not just in comparison to later versions of Visual Basic, but perhaps to modern languages in general:

3 - 1. Visual Basic 4 uses Banker's Rounding

This means that floats converted to integers will round to the nearest *even* number. This can catch you off-guard and be especially annoying if you're trying to bit shift via dividing by 2 because...

3 - 2. Visual Basic 4 Does Not Have Bitwise Operators

At least not that we could figure out! If it does, then please feel free to correct us on this. In order to compensate for this, you can do something like this:

BitShift.bas

1	Public Function ShiftRight(ByVal x As Double)
2	Dim Out As Integer
3
4	If 0 = x Then
5	'Trivial case.
6	ShiftRight = 0
7	ElseIf x Mod 2 > 0 Then
8	'Subtract 1 to make the number even to avoid weird VB rounding.
9	ShiftRight = (x - 1) / 2
10	Else
11	ShiftRight = x / 2
12	End If
13	End Function

3 - 3. Visual Basic 4 Has Objects... But Not Really Instancing...?

There is no New operator in Visual Basic 4.

To instantiate controls, you must drag them onto a form at design time. From there, you can create a control array by setting their index property to 0. You may then address other indexes at run time and use the Load statement (e.g. Load ChkExample(1)) to instantiate a new control in that array, which you can then move around the form by changing its Left/Top properties.

For more abstract uses, there are custom types, which are closer to structs. You can declare variables with them and pass them around ByRef or ByVal. They can also be marshaled into C function calls, where they behave as structs.