Pllbc2p (Precalc Linear lookup Blitter C2P)

[kevin]

                  >> Precalc Linear lookup Blitter C2P <<

                            Version: 1.20

                        Updated: 27th-March-2012

                      Original Release: 5th-08-1996

                  Written & Designed By:  Kevin Picone

       (c) Copyright 1996/2012 by Kevin Picone of Underware Design

                         All Rights Reserved.




Features:

                 * Linear Chunky Frame Buffer

                 * Single,Double & Quad Pixel widths are supported

                 * Uses Normal (none resorted Pixels)

                 * 256/64/16 Colour Versions

                 * Various Specialized C2P methods.
               
                         * Normal
                         * Delta
                         * Null Skip & Clear
                         * Delta Null Skip & Clear      (NEW to V1.04)

                 * 16bit conversion with 32bit Writes to ChipRAM

 
Special Requirements:

                 * ECS/AGA Blitter for long blits.
                 * Fastram for Precalc buffer (from 512k -> 2meg ;)
                 * Normal Planar Screen  (NOT interleaved)
                 * No Screen modulo is allowed

Disadvantages:

                 * Rather Hungry upon FASTRAM
                 * Extra ChipRAM demands
                 * Uses the Blitter   
                 * Provided Sources are *VERY* bulky
                 * Can be cumbersome to initially add





What is PLLB-C2P ?

 Precalc Linear Lookup Blitter - Chunky To Planar is actually a C2P
system and not just a few assorted routines.  The system (although it was
originally designed purely for my own use) _attempts_ to allow the
programmer too easily setup and support various bitplane depths, pixel
widths and conversion methods with relative ease.



What are 'Normal' 'Delta' & 'Nullskip' c2p routines ?

 Pllpc2p has built in support for various types of c2p conversion.  These methods are 'Normal', 'Delta', 'NullSkip' & 'DeltaNullSkip'.  I've done this for one rather obvious reason, as it's quite common that specific rendering algorithms can have their performance enhanced by using customized c2p solutions.  Hence, I've given you as many choices as I possibly could, actually I've probably gone overboard, but who cares. ;)


* Normal       - This method is the simplest type of C2P possible, each frame it will convert the entire chunky frame buffer into planar.

                 Normal C2P is probably best used when your chunky frame  buffer is constantly changing by say %80->%100.
                 

* Delta        - Delta c2p is a little more complex, it constantly takes
                 two chunky frame buffers, the chunky frame just rendered
                 and the last chunky frame rendered, and then compares
                 them, looking for differences.  Each time a difference
                 is found, it converts that group of 16 pixels into planar.

                 Delta c2p can be very powerful, and not too mention
                 quite fast in various situations. Personally, I'd recommend
                 that you use it over 'normal' c2p, or at least do some
                 performance tests yourself.

                 Those familiar with Delta C2P algo's will notice that PLLB
                 c2p allows for double buffering of your 'planar' image.
                 i.e. you don't just render over the current visible
                 frame. (So no ugly frame cuts.)

                 Moreover, Pllbc2p Delta routines, work in 16 pixel (or
                 less, depends upon the pixel width) delta fields, for
                 improved delta frequency and only shift data to ChipRAM
                 when a difference is found.


* NullSkip     - Is a specialize C2P algorithm that scans for groups of
                 NULL pixels (groups of pixel 0).  Each time it locates
                 a NULL pixel group, it performs a quick clear operation
                 to the planar buffer and then continues on, instead of
                 passing the null (clear) pixels through the c2p process.

                 NullSkip C2P is probably best used, when you can be fairly
                 sure that a large part of chunky frame buffer is going to
                 be constantly blank/clear.

                 Nullskip also clears your chunky buffer as it goes.


* DeltaNUllSkip- Is just a logical extension to 'NUllSKIP', and NO it's
                 not a combination of the 'DELTA' + 'NULLSKIP" Methods.
                 It's actually a rather simple way to reduce the chipram
                 access in the null skip algorithm.  Which is very useful
                 on high end CPU's like the 060, 040, and even 40/50mhz
                 030 systems.

                 It works via remembering if the present group of NULL
                 pixels was cleared in the planar buffer during the last
                 c2p sweep or not. If it was, then it doesn't write to chip
                 at all, if not, it performs the clear and sets the delta
                 tag for this group of pixels.  Hence, this reduces the
                 amount of chipram access and provides a handy speed-up
                 in the process.

                 DeltaNullSkip also clears out the chunky buffer while it
                 processes it.






Download

  Download Amiga Source Codes




Videos Examples


Z Rotate (Amiga)

This as a (very short) clip of another retro Amiga AGA effect.  This is one a slightly different take on the regular Z-Rotate that was common at that time (Min 90's).     It was later released as part of the experimental PLLB c2p package. Pllb is a set of C2p routines aimed at A1200 / 68020 with Fastmem.

 The demo is running _not_ running real hardware here sorry, my A1200 died long ago. None the less,  you'll be able to find the demo on my site soon enough.  

 Gouraud Cube (Amiga)

   This as a (very short) clip of another retro Amiga AGA effect, the classic gouraud cube.. Original,  I know :)..  Sadly the  video compression kills the shading a bit though.  Not too sure when this was first made now,  probably been 1995/ 1997.   The gouraud code is as you'd imagine it, pretty slow in retrospect.    I think, it was only ever released as part of the experimental PLLB c2p package.  Pllb is a set of C2p routines aimed at A1200 / 68020 with Fastmem.

  The demo is running _not_ running real hardware here sorry!, my A1200 died long ago. None the less,  you'll be able to find the demo on my site soon enough.