So you have been waiting for Basilisk II 1.0

I'm going to tell you about latest changes for AmigaOS4.1

When we talk about Basilisk its emulator for MacOS7/MacOS8, the different versions the Basilisk II 1.0 was created more or less in 2001 to 2006, after this it was almost no changes to Amiga specific stuff.

jlachmann added video switching in 2001.

cebix did some work on SCSI support.

gbeauche added copy-paste of 'TEXT' from 2004

Basilisk 0.9 comes from Ilkka "itix" Lehtoranta it was ported to MorphOS back in 2005 form a older source code, later it was upgraded with a newer UAE CPU core (from 1.0), AmigaOS4 version was heavily based on 0.9 version for MorphOS, there where few problems whit difference between AmigaOS4 and MorphOS, but the main thing the MorphOS version made easier for me to know where changes things, because CPU emulated, unlike on a Classic Amiga, I also rewrote the MUI based GUI to Reaction, it was simple to do whit few macro changes, the difference between this two GUI systems are not that big they fundamentally work the same way.

The biggest difference is that 1.0 support screen modes, and so you switch resolution whit out quieting the emulator, there are some other thins too, it was much easier to quit 0.9 then 1.0, because 1.0 does some thing strange in the interpreter, recursive callbacks makes it hard to understand what is going on, so this version does not have a quit button.

I have put copied over platform specific code from 0.9 and replaced the incompatible source code whit 1.0 and updated it, some of the changes jlachmann, cebix and gbeauche did might have been lost in the process, as for core of Basilisk 1.0 has been updated to recently a lot of work has done on SDL stuff, we only use the audio part of SDL, because AHI stuff did not work.

https://github.com/cebix/macemu/commits/master/BasiliskII?page=1

So now there is compliantly new video code for AmigaOS4, based on AmigaOS3 code, I have also added the scroll wheel support form 0.9 video drivers, the rest is new code.

Video modes supported are 2 and 256 colors and 32bit, I have dropped the 16bit video mode for now because it has to be converted to 32bit in window mode (slow), maybe add it later.

I have also experimented whit composition because its hardware accelerated, and enables fast scaling, its nice to be able to make where large window smaller, or small window whit low resolution bigger, if your playing a old game.

Disk images has been upgraded, whit support for read only disk images,

you can now also create disk images from the GUI, I have also done few more improvements to the GUI.

Virtual Amiga volume thing, is kind of buggy if you delete .finf and .rsrc directory before start emulator it work perfect or else you can get DSI error you can ignore, the best thing to point it to RAM disk, I think.

Network, file shearing, on AmigaOS is hopeless or is it?

So other platforms have DropBox and Google Drive, Samba / Mirosoft network, NFS, and so on.

We have where old version of Samba, and we are having problems whit ever dated Socket API, it put a lot of restrictions on what we can port over to AmigaOS, I think it's time we work around this problems.

We need our own file sharing system, I think this the only way we can control compatibility whit other systems we use.

We are stuck whit FTP based file shearing, and it's not horrible simple to manage.

The conclusion is that we need our own Windows/Linux/AmigaOS Client/Server software.

I have thinking the simplest form of file shearing might be some kind of file sync system.

Summer time, holyday and software development.

So what has happened sines last time, I wrote some thing here.

Excalibur 1.4.0 was released, this should have great release whit context menus, and some cool stuff like being able to hide and unhide Excalibur by Clicking the border, it was bit of horror really, last secund changes screwed up the build process, resulting half rebuilt executable, also people started reporting problems whit install and uninstall scripts.

Rebuilding Excalibur was easy, but all the changes that resulted in meny Skins/theams being out date, and was needed a work over, the result was Excalibur 1.4.1, I was not able fix problems as fast as expected because it was lot of work.

So what do I need to fix, I need to fix build horror issue, what it is.

What I have done is that I have decided the program into modules (objects), that are compiled separately and then linked into the executable. This all nice, as I don't need to see warning from modules I don't need to recompile and recompile gets quicker, less text on the screen and so on, and it organized, but his modules include some header files, that I some times need to changes, due to some structs,

but the makefile lacks the dependency and so even if I modify the header file the modules does not recompile. I'm thinking of some kind of auto clean, where if header files are changed all the objects should be deleted, forcing a make clean, make all.

Well thats the idea.

So what else, updated RunADF, well I use it a lot, I don't really have the need to mount adf's, more often I just want start a old game. The old version needed you to install UAE manually, changes stuff in user-startup, and modify DefIcons, this this are not needed in AmigaOS4.1, it was only needed in AmigaOS4.0.

DefIocns has entry for ADF files, I think its because of RunInUAE provided whit AmigaOS4.1, so all I need to do is replace sys icon, UAE is provided whit AmigaOS4.1 and so I don't need to look for it else where, so no need for UAE: Assign.

Then I was outside Norway for a week, enjoyed a week in Prague, walked around the city, I'm bit restless, I can't really sit down for too long, I need to do something, we did see a lot, I did not really dig into history of Prague or anything like that.

A bought a Samsung Galaxy, on airport, it came in heady to check on Amiga news, and look for restaurants and other useful travel information at hotel, it was also possible for me check up on work, but I tried to avoid that, unless it was needed.

Coming back after the holyday, there is some work that needs to be done on my apparent, first off this has been raining for most part this summer or I have been working, and in the weekend has been some what busy too, I have have not really have time for anything, but now, I need to get things done, only started on this, so it want be any major updates in any software until this taken care off.

One small thing I did also was release a new version in Whdload-to-UAE, that I did whit this was simular to what I did for RunADF, every thing is now provided, so made the install process easier, RunInUAE should be able to start whdload I belive but does not work here, I don't care way, all I care is that that it works, and it does after installing whdload-to-UAE, so I'm happy, hope you are.

So what to say? I think its about time to upload a new version soon.

So what to say? I think its about time to upload a new version soon, take a look at picture be under what do you think?

I don't know if notice some thing new....
but look closely, did you see it :-)

Yes the logo can now be on top, but there is some thing else....
We now how icons on About and Quit, maybe not big improvements.

But I have done allot of fixes and I hope every can notice that product is better when they use it, some of the fixes might not be easy to spot, I notice I changed the prefs, so its easier to find what your looking for.

Some of most impotent changes are fixes, found an memory leak, some problems because changing setting on the fly, lots settings did not reload as they should.

Fixed some rendering bugs.

I can say I'm really happy whit what I have done in this version, more impotent I think most of bugs is gone,  if you find a bug now its likely I do not know about it, so please rapport bugs.

So whats next, now that I bugs fixed, its time to look at things that might be nice to have.

* Context menus are on the top of that list.
* I'm also thinking about ways to hide Excalibur, I'm NOT a big fan of iconification.

I believe whit this two on the roadmap, its going to be lots of work, to one implement all the menu items. I think hiding Excalibur should be relatively easy, considering all the work being put into reloading settings, and switching resolution while program is running, it probably going to be lots of bugs during development its always is, I can't give any time estimates.

Her is a list of the changes in this version:

Version 1.3.5

* Changed: Grouping of prefs options, so its easier to find what your looking for.
* Added: A command line argument to reload to ExcaliburPrefs, this forces Excalibur to reload prefs
* Fixed:  Positioning and calculation of app icons coordinates, when prefs was reloaded.
* Added: Support for logos on top of the menu.
* Added: Loading and saving of logo placement (left,top).
* Fixed: Default settings was not set before reloading prefs
* Updated: Use presets scripts, now forces reload of settings in Excalibur
* Fixed: Crashes when changing screenmode due to changes in the way Excalibur open and close the toolbar.
* Fixed: Text length in menu,  bug was only visible when you where using a large font.
* Fixed: Menu editor so when you move a menu item up or down, the selected item stays the same.
* Fixed: Color for clock and screen did not change when config was reloaded.
* Updated: presets for Black, DjNick, 3d and Bloody
* Fixed: min_window height now its height left top+bottom or right top+bottom or center top+bottom border height.
* Fixed: Datatype support, JPG/IFF/TIFF is now converted into ARGB format, (ALPHA is assumed to be 0xFF)
* Fixed: toolbar border size for 3d and XEN, they where default 0.
* Fixed: icons in toolbar is also now reloaded.
* Added: wb96 preset for classic look.
* Fixed: fixed one pixel croping bug on icon rendering
* Changed: Max Icon size now defines height of toolbar icon not the width, (menu rendering unchanged).
* Fixed: Menu selector was misplaced on first menu, but not on sub menus.
* Changed: Logo can now be higher then the menu.
* Added: RGB and BG RGB for memory bars.
* Added: Support for icons on About and Quit menu item.
* Changed: ENVARC:Excalibur/toolbar.csv so the Excalibur menu points to SYS:Prefs/Presets/Excalibur/icons/current/Excalibur.info
* Changed: Theams to copy icons into to SYS:Prefs/Presets/Excalibur/icons/current/

So we are moving forward whit Excalibur 1.3.5.

Some really nice new features in this version, is that you do not need to quit Excalibur to reload settings. When I made the changes I discovered lots small bugs, that I have been addressing, mostly rendering related.

I most say it has been lots of bugs found I'm a bit surprised, mostly not critical, they just need to be fixed, it really does not help having lots of new features if the program is not work as expected, so this has to be fixed first.

And the second new feature is you now can have the logo on top of menus, this was not possible before, some themes might looks better whit logo on top, this was a lot of work to get right.

I also by playing a lot whit the settings I might found a lot more rendering bugs in this version, some of this bugs where not so easy to spot, I don't know if your going to see the difference.

Using datatypes (JPG,TIF,IFF images) is now working again, previously the images became transparent and was not rendered, (this going to need some more work I think, as the images loaded whit datatypes does not scale).

There is also a rendering bug in the menu that need to be fixed, when this done I will upload a new version.

I hope whit this version to have removed all known bugs, so I can start working on new features, and improvements.

I have also regrouped some prefs items so its easier to find the correct settings.

So its that time again, Excalibur is ready for new release candidate V1.3.0

So what its going on well the last version was V1.2.5 I head to do things twice because some source code was lost, in the end, the product was not as tested as it might have been if orignal was released, so this version fixed a lot the bugs and issues that where overseen in last release.

* Fixed: menu editor used wrong type id for divider.

* Fixed: rendering of 3D and XEN screens

* Fixed: Transparency was not the same for menu as toolbar.

* Disable_clock() crashed on exit, added a check if mutex is allocated.

* Fixed: menu editor, when you delete a menu, no text is printed anymore.

And then I added some new features and found a few bugs in the process, most important is the ability to test if your configuration is what you wont whit out quiting excalibur, I also added a few up and down arrows to the menu editor, so now, its not totally useless anymore, it might need some more work, but at lest I have it, in addition Exchange support was improved by not having to click the toolbar to get Excalibur to respond to Exchange, then I added a few tests to make shore Excalibur can't get 100% transparent, I know people should know better, but some go looking for bugs it seams to me.

* Added: improved icons support for only icons / all files in menus and toolbars.

* Added: move up and down to menu editor.

* Added: stupidity check for transparency, toolbar can not be less then 25 of 255.

* BB emu API MakeCommodity(), changed to return MsgPort, so I can do handel signals.

* Fixed: Excalibur should now notice when Exchange event has happened, whit out clicking on the window.

* Added: code to prevent Excalibur to be started more then once.

* Added: test button to prefs

* Added: code to unload/reload graphics, fonts and prefs.

* Fixed: Toolbar height calculation when prefs was reloaded

* Fixed: Fixed a memory leek, background bitmap not freed.

So hopefully all this changes should translate in to better user experience, I know Excalibur has long way to go, there are lots of improvements on the table, or ideas that has not yet been implemented, so don't worry this is not the last version yet.

AGA/OCS (planar) vs 8BIT CLUT (chunky)

Friday after work, and yester day I did some experimentation, people keep on saying how great AGA and OCS are for demos, is this really true? Does planar really have a advantage over 8bit CLUT chunky graphics. I think it does not, its just that planar modes, makes easier to do layering, and graphic card does the rest, so my experiment was simple implement some sort of layering in 8bit CLUT, should not be too hard.

So here is my main code, not so complicated.

#include <stdlib.h>
#include <stdio.h>

#include <proto/exec.h>
#include <proto/dos.h>
#include <proto/intuition.h>
#include <proto/graphics.h>
#include <proto/Picasso96API.h>
#include "chunky_plains.h"

int main()
{
    struct chunky_plains *cp;
    struct Screen *src = NULL;
    struct Window *win;
    struct RenderInfo ri;
    int err;
    void *tmp;
    PLANEPTR ptr;
    BPTR bmlock;
    int x,y;
    int n,anim;
    ULONG bpr;

    src = p96OpenScreenTags(
        P96SA_DisplayID, 0x50051000,
        P96SA_Title, (ULONG) "666",
        P96SA_Quiet, TRUE,
        P96SA_NoMemory, TRUE,
        P96SA_NoSprite, TRUE,
        P96SA_Exclusive, TRUE,
        TAG_END    );

    if ( src )
    {
        win = OpenWindowTags(NULL,
            WA_Left, 0, WA_Top, 0,
            WA_Width, 640, WA_Height, 480,
            WA_NoCareRefresh, TRUE,
            WA_Borderless, TRUE,
            WA_Activate, TRUE,
            WA_RMBTrap, TRUE,
            WA_ReportMouse, TRUE,
            WA_CustomScreen, (ULONG) src,
            TAG_END
        );

        if (src)
        {
            SetRGB32( &src -> ViewPort ,0,0xFFFFFFFF,0,0);

            for (y=0;y<255;y++)
            {
                SetRGB32( &src -> ViewPort ,1,y * 0x01010101, (255-y)* 0x01010101,y*0x01010101);
            }

            printf("Bitmap %x\n",src -> BitMap);
            printf("BytesPerRow %d\n", src -> BitMap.BytesPerRow);
            printf("Rows %d\n", src -> BitMap.Rows);
        }
 
        Delay(20);

        if (err = alloc_cunky_plains(win -> RPort -> BitMap, 4,4,0,0,0,0,0,0, 320,200,&cp))
        {
            printf("error code: %d\n",err);
        }
        else
        {

            for (y=0;y<255;y++)
            {
                for (x=0;x<255;x++)
                {
                    set_color(cp,0, (y^x) & 8 ? (x & 3) : (y & 3) , x ,y );
                }
            }
            Delay(100);
            for (anim = 0; anim < 5; anim++)
            for (n=0;n<32;n++)
            {
                for (y=0;y<255;y++)
                {
                    for (x=0;x<255;x++)
                    {
                        set_color(cp,1, (y^(x+n)) & 16 ? 2 : 0 , x ,y );
                    }
                }
                Delay(1);
            }
            Delay(100);

            for (anim = 0; anim < 100; anim++)
            {
                scroll(cp,0,50,50,100,100,0,1);
                scroll(cp,1,50,50,100,100,1,0);
                Delay(2);
            }
            Delay(100);

            free_chunky_plains(cp);
        }
      
        Delay(100);

        CloseWindow(win);
        p96CloseScreen(src);
    }
}

As it turns out its easy to do, I think Intel/AMD PC moved to 16bit/32bit so quickly they forgot about 8Bit/6bit graphics, there are lots of cool things you can do whit 8bit graphics like layering, fadein between layers, scroll texts that go top of some image, or having some kind of vector cube in background and some logo on top of it.

People love this tricks and there are people that do make demos whit this effects even today.

Does it make sens today? Retro is in, but it probably look a lot better in OpenGL, using the Z axes, the things you don't have so great control over in OpenGL is things you can do whit the color palette.

To test you need your own "chunky_plains.h" file, so here is the rest of the code.

struct chunky_plains {
    char bits[8];                    // bits on plain
    char index[8];                    // index bit for color
    char mask[8];                    // mask for color value
    char palette[3][8][256];            // hemm...
    int bytes_per_row;                // copy of bitmap bytes per row
    char *data;                    // ptr to the Bitmap memory
    char *f_buffer;                    // buffer so we can do filtering.
    char *n_buffer;                    // buffer so we can do filtering.
};

enum {
    cp_error_no_mem = 0,
    cp_error_too_many_bits
};

void free_chunky_plains(struct chunky_plains *p)
{
    if (p)
    {
        if (p -> f_buffer) FreeVec(p -> f_buffer);
        if (p -> n_buffer) FreeVec(p -> n_buffer);
        FreeVec(p);
    }
}

int alloc_cunky_plains(struct BitMap *bm, char n0,char n1,char n2,char n3,char n4,char n5, char n6,char n7, int w,int h,struct chunky_plains **new_cp)
{
    struct chunky_plains *p;
    int n;
    int cnt;
    int bpr;
    int error_code = 0;

    p = (struct chunky_plains *) AllocVec( sizeof(struct chunky_plains) , MEMF_ANY );

    if (p)
    {
        bpr = p96GetBitMapAttr(  bm, P96BMA_BYTESPERROW);   

        p -> data =  (char *) p96GetBitMapAttr( bm , P96BMA_MEMORY);
        p -> f_buffer = (char *)  AllocVec( bpr * h , MEMF_ANY | MEMF_CLEAR);
        p -> n_buffer = (char *)  AllocVec( bpr * h , MEMF_ANY | MEMF_CLEAR);
        p -> bytes_per_row = bpr;

        p -> bits[0]=n0;
        p -> bits[1]=n1;
        p -> bits[2]=n2;
        p -> bits[3]=n3;
        p -> bits[4]=n4;
        p -> bits[5]=n5;
        p -> bits[6]=n6;
        p -> bits[7]=n7;

        p -> index[0] = 0;

        cnt = 0;
        for (n=1;n<8;n++)
        {
            p -> index[n] = p -> index[n-1] + p -> bits[n-1];

            cnt += p -> bits[n];
        }

        for (n=0;n<8;n++)
        {
            p -> mask[n] = ((1 << p -> bits[n]) -1) << p -> index[n];

            printf("bits %02x mask %02x index %d\n",p -> bits[n] ,p->mask[n], p -> index[n]);
        }

        if (cnt > 8) error_code = cp_error_too_many_bits;
       
        if (!p -> data)    error_code = cp_error_no_mem;
        if (!p -> f_buffer) error_code = cp_error_no_mem;
        if (!p -> n_buffer) error_code = cp_error_no_mem;

    } else {
        error_code = cp_error_no_mem;
    }

    if (error_code)
    {
        free_chunky_plains(p);
        p = NULL;
    }

    *new_cp = p;

    return error_code;
}


void set_color(struct chunky_plains *cp, char number, char color, int x,int y)
{
    char *pixel = &cp -> data[ x + (cp -> bytes_per_row * y)];
    *pixel = (~cp -> mask[number]) &  *pixel | (color << cp -> index[number] );
}

int get_color(struct chunky_plains *cp, char number, char color, int x,int y)
{
    return (cp -> mask[number] &  cp -> data[ x + (cp -> bytes_per_row * y)]) >> cp -> index[number] ;
}

void scroll(struct chunky_plains *cp, int number, int x1,int y1,int x2,int y2, int offset_x, int offset_y )
{
    int fmask = ~ cp -> mask[number];
    int mask = cp -> mask[number];
    int bytes_per_row = cp -> bytes_per_row;
    register int x = 0;
    register int y;
    register int line_offset;
    register int offset;
    register int doffset;

    // we filter out the other plains into the buffer, so we can put it back in.

    for (y =y1;y<=y2;y++)
    {
        line_offset = y *  bytes_per_row;
        for (x=x1;x<=x2;x++)
        {
            offset = line_offset +x;
            cp -> f_buffer[offset] = cp -> data[ offset ] & fmask;
            cp ->n_buffer[offset] = cp -> data[ offset ] & mask;
        }
    }

    for (y =y1;y<=y2;y++)
    {
        line_offset = y * bytes_per_row;
        for (x=x1;x<=x2;x++)
        {
            offset = line_offset +x;

            doffset = (y + offset_y) * bytes_per_row + (x + offset_x);

            cp -> data[ offset ] = cp -> f_buffer[offset] | cp ->n_buffer[ doffset ] ;
        }
    }
}