Will be great to have a devkit like TommyGun for Linux. I will check if TommyGun runs on Linux with Wine.

Quote:

Will be great to have a devkit like TommyGun for Linux. I will check if TommyGun runs on Linux with Wine.

It should as it uses no special Win32 or DirectX stuff - normal GDI only (not GDI+) and standard Win32 controls.

Quote:

You may also say that Qt has the open source version which is free. True - but the license says your software must also be open source of which mine is not at the moment. I may release it eventually as open source but at the moment it isn't. No real reason not to release it as open source other than I don't have time and the code needs a little tidy up - plus I would have to document the design which would take a long time as well. Need the time to add more features!

What do you need the time for? Just put the code somewhere, add the license file and you're done. You don't have to document it (although it would be easier). So, open sourcing it takes about 10 minutes. I'm sure you have that time.

Anyway, if you link it to Qt, you indeed have to license it as GPL. multi, you should read the GPL better:
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.

Qt is under the GPL, so it is not allowed to link a proprietary program to Qt.

manuel, als long as you dynamically bind, there is no legal way that GPL can tell you what your work should be licensed with. basically a license can only infect a derived work, not a new work. the word derived work is a legal word, it means that the code you wrote should contain copyrighted work. but with dynamic linking this is not the case. not even the header info compiled into your executable is copyrighted material !!!! this means that as soon as you dynamically link to any GPL code, by law the GPL license can never "infect" your license.

it might that GPL shows it's teeth and make you think they can do anything they claim, in reality there is nothing they can claim about your own copyrighted work. not even if you "use" the library, because the only legal thing a license can talk about are "derived works", and not used works or dependant works (this is very important to understand and very often misunderstood about GPL)

http://en.wikipedia.org/wiki/Derivative_work

the LGPL license is made mainly for static linking and inheriting classes.





quote from http://www.linuxinsider.com/story/33968.html

If the software system is not a derivative work, a copyright license is not needed unless there is some other relationship between the parties that creates other obligations. This is true regardless of the nature of the licenses obtained for the prior work. This is also true regardless of the opinions of the author of the prior work.

Contrary to what some operatives might want us to think, the GPL and other open-source licenses do not have some special magic feature that allows them to infect other software. They have license limitations that apply to derivative works, just like any other copyright license.

I have been checking out QT and it has everything I need to port TommyGun to be a cross-platform tool.
If I need to release the code as open source to use then release it I will
Very excited about using Qt to do it - so excited that I may even experiment with it after doing the MSX changes to TommyGun

TommyGun installs en runs with Wine. I hadn't the time to check things.

multi, check this: http://www.fsf.org/licensing/licenses/gpl-faq.html#IfLibraryIsGPL

This is what Trolltech (authors of Qt) want. It's how they licensed their software, deliberately. So, I'm not sure what you mean with "there is nothing they can claim about your copyrighted work". Who is they?

If you don't agree to the GPL, then don't use Qt (or other software licensed under the GPL).

kiwi: great news

Ok, Enterprise support is complete so its onto the MSX1

If understand correctly MSX1 uses the VDP 9918. (jltursan)
http://en.wikipedia.org/wiki/Texas_Instruments_TMS9918
It seems to have some very strange modes.
One question is about mode 1 - is this mode used at all - ie. is it very popular?
How is the display buffer laid out for this mode?
Is it possible to set a pixel using a bitmap display buffer or do you have to set the pixel in the character of the selected character set to make the change.
In other words if you defined a bitmap to draw in this mode - what format would the bitmap take?

Mode 2 seems like the Spectrum style mode.
4 bits per colour so it seems to have a bitmap buffer and an attributes buffer - correct?
Much like the sam coupe mode 2 and Enterprise 16 colour mode.
The bitmap buffer says what pixel is set and the attributes buffer says what colours the 8 pixels have.
For set pixels in uses 1st 4 bits of the attribute value and for unset pixels it uses the last 4 bits of the attribute value.

What are the RGB values of the MSX1 palette? All 16 of them. 0 being - black or transparent I take it.

Mode 3 is a silly mode and is similar to the Jupiter ACEs only graphic mode except it has colour.
How is the display memory laid out for this mode? ie is it pixels/attributes or pixel colours only.

When I ask "how is display memory laid out" I mean that if I poked a value into display what color/graphic would show.
Or if I defined a bitmap image to show in that mode what format would the bitmap take?
ie. how do set the correct bits for a display mode for each colour it supports.

Also sprites are monochrome (their format is - I know you can select a colour it) so that means a sprites format only stores if a pixel is set or not.
Does the sprite format use any interfaced bits or is it simply a bit to bit match for a pixel on the display.
eg.
non-interfaced: 11110000 -> would show 4 pixels on - 4 pixels off
interlaced could be 1010101 to show the same 4 pixels on - 4 pixels off
I ask this because several machines have interlaced display formats. - crazy computers

Thank for the help.
Will start on the MSX1 plugins as soon I get all the info I need.
Cheers

Also does the MSX1 use the TMS9918 or the TMS9918A
As there is no MODE 2 in the standard TMS9918.

Can you have multicolor sprites on MSX+/2?

On MSX1, mode 2 is the most used. It is a pattern mode which defines three banks of 256 patterns. Each pattern has 8 bytes in the pattern generator table to define the pattern and 8 bytes in the color table to define the foreground and background colour for each line. Look here for the palette for MSX1.

Sprites are defined similar to patterns. Basically 256 8x8 patterns. When in large sprite mode, a sprite is built from four patterns, resulting in 64 sprites (with numbers that are multiples of 4). Pattern order: left top, left bottom, right top, right bottom.

The memory layout is variable as it can be selected through registers (with some restrictions), but common is:
$0000 Pattern generator table (pattern bitmaps), 3x 2K
$1800 Pattern Name Table (screen), 768 bytes
$1B00 Sprite attribute table, 128 bytes
$2000 Colour table, 3x 2K
$3800 Sprite pattern table, 2K

Mode 4 on MSX2 is almost the same as Mode 2, but with coloured sprites instead. For each of the 32 entries in the sprite attribute table (not the sprite patterns!), you can define 16 bytes for the colour of each line. There's also the option to mix two sprites to get three colours. Of course, MSX2 has a palette that works in all modes but mode 8. Also, with more video memory, there is the option to store a lot more data.

Apart from that, Mode 5 is used much on MSX2. This is a regular bitmap mode. 256x212 in 16 colours.

You'll be happy to know there is no crazy interlaced data stuff

Most of the information that you need is listed on this page.

I guess this is plenty of information to digest. If you have any questions, please ask!

Good luck!

Thanks Edwin - more questions

ok, if I was to create an 8x8 sprite what data would be produced for each element described above?

00111100
01000010
01000010
01111110
01000010
01000010
01000010
00000000

So for the letter A example above what data is put into
1) the Pattern Generator Table
2) Pattern Name Table
3) Sprite Attribute Table
4) Colour Table
5) Sprite Pattern Table

The Portar page is quite useful - except it doesn't really go into explaining the above tables and also examples would be very useful indeed.

Also if you could supply the same information for a 16x16 sprite that would be good too.

It maybe a good idea to explain "Patterns" to me a little more.
It seems like Screen 2 is very ZX Spectrum like but with more badly described description of what is going on.
Is the screen 2 memory laid out the same as the spectrum?
ie. 6144 bytes of pixel buffer made up of 3 sections of 2048 bytes and 1 linear 768 attribute buffer.
The trick with the spectrum is that the 2K sections of the pixel buffer are not linear in that line 1 (0 start) is not at address offset 32 this offset in the start of the second character or 8 pixels down from the top.
This means to get to a new row inside a character square you simple increment the high byte of the screen address.
Neat trick for drawing characters fast - but a real bugger for sprites.

Quote:

multi, check this: http://www.fsf.org/licensing/licenses/gpl-faq.html#IfLibraryIsGPL This is what Trolltech (authors of Qt) want. It's how they licensed their software, deliberately. So, I'm not sure what you mean with "there is nothing they can claim about your copyrighted work". Who is they? If you don't agree to the GPL, then don't use Qt (or other software licensed under the GPL).

"they" is anyone who takes it to court. and of course i don't use GPL or LGPL in my code because i think the people who are behind GPL & LGPL are totally nuts. thats besides the point though and has nothing to do with law.

the main misunderstanding on GPL is that (from a law perspective) GPL only lifts your copyright infridging activities by saying that as soon as you infridge, you become co-author. this then means that the other part of your code (newly written code) becomes part of the whole work and falls under the already existing license (GPL).

this is only possible when you really infridge copyrights though! the words seem to say something else, but you need to remember they are written in the language the law uses. the words do not always mean what they seem to someone who is not a lawyer i guess.

to infridge work you need to copy significant parts of it (copy/paste or include), this only happens when you statically bind or when you expand the code. when you dynamically bind to the code you do not copy anything from the origional. especially when you remember that it is legal to quote an author! (that is important because it is the part in the copyright law that allows us to include function prototypes without infridging)

a dynamically linked work is (as far as the law looks at it) NOT a copyright infridgement and therefore the license has nothing to do with it. so you do not need a license to lift your copyright infridging activities if you were not infridging to begin with. thats all i was saying. a legal way to limit the use (other then infridging) of a program would be with a EUA (e.g. permission to use but not own the copy).

i have to say though that i don't know for sure if Qt on linux is available as a binary that can be dynamically linked or not, i just assumed this because it is under windows. but if so, there is no conflict of license.

For both a pattern and sprite the above bitmap would be simple: $3c, $42, $42, $7E, $42, $42, $42, $00. The pattern generator table contains 3 sets of 256 of those.
In the colour table you would have 8 bytes. For each line the foreground colour in the high nibble and the background colour in the low nibble. So eight time $F0 for a white letter an a black background. Or $E0, $F5, $E0, $F5, $E0, $F5, $E0, $F5 for some more creative alternating black/blue background.

The name table is basically 768 pattern numbers. For the first 8 lines, the byte refers to a pattern in the first set, for the lines 8-15, the second set, etc.

A 16x16 rectange sprite would be:
$FF, $80, $80, $80, $80, $80, $80, $80
$80, $80, $80, $80, $80, $80, $80, $FF
$FF, $01, $01, $01, $01, $01, $01, $01
$01, $01, $01, $01, $01, $01, $01, $FF

Memory is pretty linear. Pattern and colour data is described in 8 consecutive bytes. So the address of pattern data for pattern N is simply 8*N for set the first set, 8*N+$800 for the second set and 8*N+$1000 for the third set. Same for the colours but with an additional $2000 offset.

The screen shows 32x24 patterns. So $1800+32*Y+X. Luckily, everything is pretty straightforward.

Multi> you post really reads like M$ FUD and it's a completely skewed view of what the GPL is.

The GPL is basically very simple. If *you* want use a piece of GPL'd work, then the GPL says that you can do so if you release *your* work as GPL as wel. It doesn't take copyright or infringe anything. It just gives you a requirement for using something. If you don't like the requirement, then don't use it. It's your choice.

LGPL, is slightly less strict in that it will allow linking (as .dll or .so for instance) by programs under a different license. Nothing more, nothing less.