Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.


Topics - boogop

Pages: [1]
1
ASM / sine generator in TASM
« on: August 14, 2018 »

I'm working on a small plasma in TASM. It's very vanilla and not very interesting except for the sine generator. I was struggling with a big list of sine constants (originally I'd exported them from c#, double d = 32 + 32 * Math.Cos((i * 6.28) / 256)) when I came upon this generator in a prod by insomniac/matrix. But I'm not good enough at asm to tell exactly how it's working, except that wally/rage (??) was pretty darn clever. 188 bytes but I'm also getting some annoying color banding from stosw

Code: [Select]
; tasm /m2
; tlink /t

cseg    segment
assume cs:cseg
org 0100h
.286

start:
    mov     ax,13h              ; set mode 13
    int       10h
    push    0a000h              ; stick video segment in es
    pop      es
               
    mov     dx,3c8h             ; set color index port
    xor       ax,ax
    out       dx,al                ; output color index 0
    inc       dx                    ; inc dx = 3C9h, color write port
@redup:                          ; Set colors 0-62, ramp up red
    out      dx,al                  ; set red to value in al
    xchg    al,ah                 ; ah is 0, so exchange it with al
    out      dx,al                  ; set green and blue = 0
    out      dx,al
    xchg    al,ah               ; swap ah/al so al is again non-zero
    inc      al                     ; al +=1
    cmp     al,63
    jne     @redup
@reddn:                         ;set colors 63-127, ramp down red
    out     dx,al
    xchg    al,ah
    out     dx,al
    out     dx,al
    xchg    al,ah
    dec     al
    jnz     @reddn
@blueup:                        ;set colors 127-194, ramp up blue
    xchg    al,ah
    out     dx,al
    out     dx,al
    xchg    al,ah
    out     dx,al
    inc     al
    cmp     al,63
    jne     @blueup
@bluedn:                        ;set 194-256, ramp down blue
    xchg    al,ah
    out     dx,al
    out     dx,al
    xchg    al,ah
    out     dx,al
    dec     al
    jnz     @bluedn
                                ; sin generator from argon by insomnia/matrix
                                ; who got it from Wally/Rage, but I'm not sure
                                ; who that was. There was a Rage demogroup
                                ; in the amiga scene. Anyway, credit to the
                                ; original author. My big list of sin constants
                                ; was taking up ~200 bytes

    mov     cx,783Fh            ; [30783]
    xor     si,si
sin1:   
    mov     ax,65497
    imul    cx                  ;[2016194151]
    add     si,dx               ; results of imul are stored in dx:ax [782C AE67, si+=30764]
    add     cx,si               ; [783F + 782C,cx=30783+30764=61547=F06B]
    mov     [bx],ch             ; [[bx]=F0=240]
    sar     byte ptr [bx],1     ; divide the value by 2, only store a byte [bx=120?]
    dec     bx                 
    cmp     bx,16383           
    jne     sin1

   ; inc     bx                  ; BX points to the sine/cos-values [comment by insomnia but this step isn't needed and saves a byte]
    mov     si,bx               ; move it to SI since I need BX

main:

;------- main program ------------
    xor     di,di               ; Reset vga position

    mov     cl,[p_pos1]         ; stick plasma position values into ch,cl
    mov     ch,[p_pos2]

    mov     ah,200              ; 200 rows in mode 13               
Y_LOOP:
    push    ax                  ; ax is also our x counter, so save
                                    ; the y vals to test later
    mov     dl,[p_pos3]         ; the other position values in dh,dl
    mov     dh,[p_pos4]         ; now the plasma position vals are in cx/dx

    mov     ah,160              ; X counter. since we're using stosw we only have to loop 320/2 times
X_LOOP:
    xor     al,al               ; al holds the color, so clear it

                                ; x = SinTable[p_pos1] + SinTable[p_pos2] + SinTable[p_pos3] + SinTable[p_pos4]
    mov     bl,dl               ; mov p_pos3 into bl   
    add     al,si[bx]           ; x += Sin[p_pos3]
    mov     bl,dh               ; mov p_pos4 into bl   
    add     al,si[bx]           ; x += Sin[p_pos4]
    mov     bl,cl               ; mov p_pos1 into bl   
    add     al,si[bx]           ; x += Sin[p_pos1]
    mov     bl,ch               ; mov p_pos2 into bl   
    add     al,si[bx]           ; x += Sin[p_pos2]

    ; push    cx                ; save the position vals
    ; mov     cx,4              ; write 4 pixels at a time
    ; rep     stosb             ; put pixel cx times in es:di, advancing the screen pointer
    ; pop     cx                ; restore position vals
    stosw                       ; stosw is smaller than that noise

    add     dl,2                ; add movement var to p_pos3
    add     dh,1                ; add movement var to p_pos4

    dec     ah                  ; decrement the x counter
    jnz     X_LOOP              ; test for 0

    add     cl,2                ; add movement var to p_pos1
    add     ch,3                ; add movement var to p_pos2

    pop     ax                  ; restore the y counter
    dec     ah                  ; Next vertical line
    jnz     Y_LOOP              ; test for 0

    add     [p_pos1],2          ; add some vals to the position vars
    add     [p_pos2],3          ; speed up/slow down the plasma
    sub     [p_pos3],1
    add     [p_pos4],4

    jmp     main                ; do it all again
 
    p_pos1   db 0
    p_pos2   db 0
    p_pos3   db 0
    p_pos4   db 0

    ; SinTable  db 64,63,63,63,63,63,63,63,63,63
    ; db 63,62,62,62,62,61,61,61,60,60
    ; db 60,59,59,59,58,58,57,57,56,56
    ; db 55,55,54,54,53,52,52,51,51,50
    ; db 49,49,48,47,47,46,45,44,44,43
    ; db 42,42,41,40,39,39,38,37,36,35
    ; db 35,34,33,32,32,31,30,29,28,28
    ; db 27,26,25,25,24,23,22,21,21,20
    ; db 19,19,18,17,16,16,15,14,14,13
    ; db 12,12,11,11,10,9,9,8,8,7
    ; db 7,6,6,5,5,4,4,4,3,3
    ; db 3,2,2,2,1,1,1,1,0,0
    ; db 0,0,0,0,0,0,0,0,0,0
    ; db 0,0,0,0,0,0,0,0,0,1
    ; db 1,1,1,2,2,2,3,3,3,4
    ; db 4,4,5,5,6,6,7,7,8,8
    ; db 9,9,10,11,11,12,12,13,14,14
    ; db 15,16,16,17,18,18,19,20,21,21
    ; db 22,23,24,24,25,26,27,28,28,29
    ; db 30,31,31,32,33,34,35,35,36,37
    ; db 38,38,39,40,41,41,42,43,44,44
    ; db 45,46,47,47,48,49,49,50,50,51
    ; db 52,52,53,54,54,55,55,56,56,57
    ; db 57,58,58,58,59,59,60,60,60,61
    ; db 61,61,62,62,62,62,63,63,63,63
    ; db 63,63,63,63,63,63


cseg ends

End Start

2
General coding questions / voxel waves
« on: April 04, 2018 »
Does anyone know of or have an example of this effect, the one that future crew had in second reality? The only example I've been able to find is by Insolit Dust who used to post here, but it's difficult to read and has enough hardcoded values that I can't really tell what it's trying to do. Any language should be okay, but it's more difficult for me to deconstruct an xy location if the video is addressed like unsigned char *b = DBuf + (a << 8) + (a << 6) + i;


snippet from insolit dust, he posted a link to his site here so I hope this is okay!

Code: [Select]
void Line(int x0, int y0, int x1, int y1, int hy, int s)
{
register int i;
     int sx, sy;
     int c,y,h,u0,v0,u1,v1,a,b,h0,h1,h2,h3;
     
     sx = (x1 - x0) / 320;
     sy = (y1 - y0) / 320;
     
     for (i = 0; i < 320; i++)
     {
         u0 = (x0 >> 16) & 0xFF;
         a = (x0 >> 8) & 255;
         v0 = ((y0 >> 8) & 0xFF00);
         b = (y0 >> 8) & 255;
         u1 = (u0 + 1) & 0xFF;
         v1 = (v0 + 256) & 0xFF00;
         
         h0 = HMap[u0 + v0];
         h2 = HMap[u0 + v1];
         h1 = HMap[u1 + v0];
         h3 = HMap[u1 + v1];
         
         h0 = (h0 << 8) + a * (h1 - h0);
         h2 = (h2 << 8) + a * (h3 - h2);
         h = ((h0 << 8) + b * (h2 - h0)) >> 16;
         
         h0 = CMap[u0 + v0];
         h2 = CMap[u0 + v1];
         h1 = CMap[u1 + v0];
         h3 = CMap[u1 + v1];
         
         h0 = (h0 << 8) + a * (h1 - h0);
         h2 = (h2 << 8) + a * (h3 - h2);
         c = ((h0 << 8) + b * (h2 - h0));
         
         y = (((h - hy) * s) >> 11) + (240 / 2);
         
         if (y < (a = LastY[i]))
         {
                unsigned char *b = DBuf + (a << 8) + (a << 6) + i;
                int sc,cc;
               
                if (LastC[i] == -1)
                   LastC[i] = c;
                   
                sc = (c - LastC[i]) / (a - y);
                cc = LastC[i];
               
                if (a > 240 - 1)
                {
                      b -= (a - (240 - 1)) * 320;
                      cc += (a - (240 - 1)) * sc;
                      a = 240 - 1;
                }
               
                if (y < 0)
                   y = 0;
                   
                while (y < a)
                {
                      *b = cc >> 18;
                      cc += sc;
                      b -= 320;
                      a--;
                }
               
                LastY[i] = y;
         }
         
         LastC[i] = c;
         
         x0 += sx;
         y0 += sy;
     }
}

3
Boogop's amazing summer demo! Loaded with ancient crusty effects you've seen a gorillion times before! Absolutely no new ground broken whatsoever!

Kludged up in Freebasic, Tinyptc_ext by RBZ, FMod for music (could have used Tinyptc_ext++ herp derp), FPS limiter by RBRAZ, FFNT_Lib by Deleter. Music is d3.mod by Necros. Is there anything in here by me?!


4
Freebasic / Dot Tunnel
« on: November 17, 2016 »
Dot tunnels gave me fits trying to figure out. So here's one for the lulz, maybe it will help (or hinder) someone else!

Code: [Select]
'''''''''''''''''''''''''''''''''''''''''''''''''''''''
' DOT TUNNEL
' by boogop
' The c# logic from my entry for the Amiga
' demo a year or so ago
' - now in glorious lo-res!
'
' For me, dot tunnels were the hardest effect
' to figure out. There didn't seem to be many
' examples (before I found dbfinteractive, on
' which there are several) and the ones I could
' find on the intarnets or hornet archive were
' frequently not very good. Some of them
' weren't tunnels at all, they were tubes with the
' rings fixed in place. The best one I ever saw
' was Crystal2 BBS addy by Xography but they never
' released the source, and I haven't been able to
' figure out how they were handling the movement path
'''''''''''''''''''''''''''''''''''''''''''''''''''''''

#include "tinyptc_ext.bi"

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' screen dimensions & put_pixel routine
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
const screenWidth = 320
const screenHeight = 200
const SCR_SIZE as integer = screenWidth*screenHeight

dim shared buffer( 0 to SCR_SIZE-1 ) as integer
dim shared as uinteger ptr pntr
dim shared as integer ptr p

declare sub put_pixel(buffer() as integer, byval x as integer, byval y as integer, byval col as integer)

' this may be Shockwave's routine!
sub put_pixel(buffer() as integer, byval x as integer, byval y as integer, byval col as integer)

    if(y < screenHeight -1 and y > 1) then
        if( x < screenWidth-1 and x > 1 ) then
           
            PNTR = @buffer(y * screenWidth + x)   
         
            asm
                mov eax, dword ptr[col]
                mov edi, [pntr]               
                stosd
            end asm           
     
        end if
    end if

end sub

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' declare variables
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
 
type colors
    dim as integer r,g,b
end type

dim shared as colors colArray(256)

const _pointsPerCircle = 20
const _numCircles = 35
dim shared as double zDistance = 8

' named star because I lifted it from my 3d starfield code :)
type star
    dim as double xpos, ypos, speed, zpos
    dim as double origX, origY, origZ
    dim as integer oldx,oldy
end type

dim shared as star circles(_numCircles, _pointsPerCircle)

dim shared as double maxZ = 0
dim shared as double diam = 50
dim shared as double xp,yp,zp,increment, px, py, skew, skewCount
dim shared as integer angle = 0
dim shared as double zPos = 1
dim shared as integer angleAdder = int(360 / _pointsPerCircle)     
dim shared as double zPosAdder
dim shared as double midWidth = screenWidth / 2
dim shared as double midHeight = screenHeight / 2
dim as integer i,j, xpathcount
dim as double rad = 3.1416 / 180.0

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' set initial values
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
skewCount = .0001
zPosAdder = zDistance / _numCircles

for  j = 0 to  _numCircles
   
    for  i = 0 to _pointsPerCircle
   
      dim as double Y =  diam * Sin(angle * rad)
      dim as double X = 2 * diam * Cos(angle * rad) ' make it oval shaped for the lulz
      circles(j, i).xpos = X
      circles(j, i).ypos = Y
   
      circles(j, i).speed = .0025
      circles(j, i).zpos = zPos
      circles(j, i).origX = X
      circles(j, i).origY = Y     
      circles(j, i).oldx = 0
      circles(j, i).oldy = 0
   
      angle += angleAdder
   
    next i
zPos += zPosAdder
next j
     

maxZ = 0

' figure out the largest z value
for  j = 0 to _numCircles
    for i = 0 to _pointsPerCircle     
        if circles(j, i).zpos > maxZ then
            maxZ = circles(j, i).zpos
        end if   
    next i
next j

increment = 0

' fill color array     
i = 0
while i < 256     
    dim as single red = 1 + Cos(i * 3.14 / 128)
    dim as single grn = 1 + Cos((i - 85) * 3.14 / 128)
    dim as single blu = 1 + Cos((i + 85) * 3.14 / 128)
    colArray(i).r = int(red * 127) mod 256
    colArray(i).g = int(grn * 127) mod 256
    colArray(i).b = int(blu * 127) mod 256
    i = i+1
wend

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' run the thing
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

'ptc_setdialog(1,"FullScreen?",0,0)
if( ptc_open( "freeBASIC - tinyPTC Dot Tunnel", screenWidth, screenHeight ) = 0 ) then
    end -1
end if

while inkey() <> chr(27)   
 
    if skew <= 1 then
        skew = skew + skewcount
    end if
   
    for  i = 0 to _numCircles
       
        for  j = 0 to _pointsPerCircle
           
           ' erase the last point
            put_pixel Buffer(),circles(i, j).oldx,circles(i, j).oldy,0
            put_pixel Buffer(),circles(i, j).oldx+1,circles(i, j).oldy,0
           
            ' bring each circle towards the viewer
            circles(i, j).zpos -= circles(i, j).speed
           
            ' if a circle is close enough to the viewer, send it to the back
            ' using the maximum z value
            if circles(i, j).zpos < 2 then           
                circles(i, j).xpos = circles(i, j).origX
                circles(i, j).ypos = circles(i, j).origY
                circles(i, j).zpos = maxZ
            end if
           
            ' most compilers will perform some kind of bounds checks, and those
            ' will really bog an app down. Cast the array to vars so any bounds
            ' checking only has to happen once
            xp = circles(i, j).xpos
            yp = circles(i, j).ypos
            zp = circles(i, j).zpos
           
            ' kludgey color fader lol
            dim as double cc = 1 - Abs(zp / (maxZ * .8))
            if (cc < 0) then
                cc = 0
            end if
            if (cc > 1) then
                cc = 1
            end if
            dim as integer c = int(300 * cc)
            if c > 255 then
                c = 255
            end if
            dim as integer co = rgb(colArray(c).b,colArray(c).r,colArray(c).g)
            if zp > int(maxZ * .6) then
                co = rgb(colArray(c).b/2,c,c)
            end if       
       
           ' zpos isn't quite right and doesn't bring the circles as close
           ' as it should but I don't feel like fixing it!
            dim as double z = zp - 1.5
           
            ' path of the tunnel
            px = 50 * Sin(z * skew * sin(increment))
            py = 40 * Cos(z * skew * cos(increment))           
           
            ' calculate perspective, add path, align to center screen
            dim as double sx = (xp / z) + px + midWidth
            dim as double sy = (yp / z) - py + midHeight
           
            dim as integer ix = int(sx)
            dim as integer iy = int(sy)
                     
            put_pixel Buffer(),ix,iy,co
            put_pixel Buffer(),ix+1,iy,co           
           
            ' save the current pos so we can erase it in the next iteration
            circles(i, j).oldx = ix
            circles(i, j).oldy = iy
           
        next j
    next i   
   
   
    increment +=.0005   
       
    ptc_update @buffer(0)


  wend



5
Freebasic / Fractal Zoomer
« on: November 09, 2016 »
Here's a version of the fractal zoomer from R.I.P. Boogop converted to freeBasic/ASM. I'd love to figure out a way around having to iterate over each pixel 300 times because that's where all your performance goes. It drives me nuts. This seems about as optimized as I know how to make it; if you focus optimizing anywhere else but the iteration loop it's a red herring, that loop is the killer. There are ideas around to split the screen in half and render each half in a separate thread, but that's still working around the central problem of the inability to determine if an equation is going to go to infinity without doing it 300 times.

On my work PC (LoMem Kludge-0-Matic 100) I get to the lose-resolution point in about 22 seconds. If you want to go deeper you'll need to tweak horizPosAdjust and vertPosAdjust to position yourself where you want to be

Code: [Select]
''''''''''''''''''''''''''''''''''''''''''''''''''
' MANDELBROT ASM ZOOMER TEST
' by boogop
' this may be a little faster than the FB version
' but I'm sure I've done lots of stuff wrong or fb
' is just smarter than I am lol
' Where this loses resolution is about the limit
' of a single data type. Converting to double will
' zoom farther in but also take longer
''''''''''''''''''''''''''''''''''''''''''''''''''

#include "tinyptc_ext.bi"

' 350 x 325 to size it the same as the c# effect
dim shared as integer screenWidth = 320
dim shared as integer screenHeight = 200
const SCR_SIZE as integer = 320*200

dim shared as integer ptr p

dim shared buffer( 0 to SCR_SIZE-1 ) as integer
dim shared as uinteger ptr pntr

dim shared as integer w, h, h2

' initial vals
dim shared as single a1 = -2.5
dim shared as single b1 = -1.5
dim shared as single ax1 = -2.5
dim shared as single ax2 = 1.5
dim shared as single bx1 = -1.5
dim shared as single bx2 = 1.6

dim shared as single bailnum = 2.0
dim shared as single bailGT1 = 1.3
dim shared as single bailLT1 = -1.3

dim shared as single z1, z2, z3, dx, dy, crx, yy, cr, ci', dydx
dim shared as integer k = 0   

dim shared as single ww
dim shared as single hh
dim shared as single a1w, b1h
dim shared as single aw
dim shared as single bh

dim shared as single zoom = 1

dim shared as uinteger colSingle(300)

declare sub init
declare sub DrawMandelbrot
declare sub CreateMandelbrot(a1 as single, a2 as single, b1 as single, b2 as single)
declare sub put_pixel(buffer() as integer, byval x as integer, byval y as integer, byval col as integer)



sub init   
   
    w = screenWidth
    h = screenHeight   
    h2 = h / 2     
   
    ' these coords put us in scepter valley
    a1 = 153.41801 
    b1 = h2 - 8.650006   
   
    ' if you change the size of the window you have to figure out where in the
    ' mandelbrot set you are - not easy! >:(
    dim as single horizPosAdjust = 13.24
    dim as single vertPosAdjust = 1.5
   
    a1 = a1 - horizPosAdjust
    b1 = b1 - vertPosAdjust
   
    ww = ax2 - ax1
    hh = bx2 - bx1
   
    a1w = a1 * ww
    b1h = b1 * hh
   
    aw = a1w / w
    bh = b1h / h
   
    dim i as integer = 0
    ' usually the array would be dimensioned to 256 but if we set it to the
    ' number of iterations we can skip a mod operation
    while i < 300     
        dim as single red = 1 + Cos(i * 3.14 / 128)
        dim as single grn = 1 + Cos((i - 85) * 3.14 / 128)
        dim as single blu = 1 + Cos((i + 85) * 3.14 / 128)       
        dim as integer r = int(red * 127) mod 256
        dim as integer g = int(grn * 127) mod 256
        dim as integer b = int(blu * 127) mod 256
       
        colSingle(i) = rgb(r,g,b)     
       
        i = i+1
    wend
   
       
end sub



sub DrawMandelbrot   
   
    zoom = zoom + (zoom * .05)
    dim as single d = zoom + zoom
   
    dim as single wax = ww / d
    dim as single wah = hh / d   
   
    dim as single newleft = aw + ax1 - wax
    dim as single newright = aw + ax1 + wax
    dim as single newtop = bh + bx1 - wah
    dim as single newbottom = bh + bx1 + wah
   
    CreateMandelbrot(newleft, newright, newtop, newbottom)
   
end sub

sub CreateMandelbrot(a1 as single, a2 as single, b1 as single, b2 as single)
   
    p = @buffer(0)
   
    dim as single dr = (a2 - a1) / w
    dim as single di = (b2 - b1) / h
    dim as integer j = 0
    dim as integer i = 0
    dim as single temp, q, a, b
    dim as single dx1, dy1
   
    dim as single ptr t
    'dim as string key
   
    for j = 1 to h
       
        ci = b1 + j * di 
       
        for i = 0 to w-1
           
            cr = a1 + i * dr
           
            dx1 = 0.0
            dy1 = 0.0         
                   
            ' PERIOD CHECKING
            ' if we can tell we're inside the cardiod or period-2 bulb we can skip the iterations.
            ' period checks make the routine blaze until we're past them but the iteration loop is
            ' the big problem
            crx = cr + 1.0
            yy = ci * ci
           
            if ((crx * crx) + yy < .0625) then
               
                ' checks for a point inside the period-2 bulb
                ' but once you're past that it does nothing
                *p = 0
                goto bail
               
            end if
           
            ' check for cardiod bulb
            temp = cr - .25
            t = @temp
           ' q = temp * temp + yy
            q = (*t) * (*t) + yy
            a = q * (q + *t)
            b = .25 * yy
            if (a < b) then
               
                *p = 0
                goto bail
               
            end if
           
            ''''''''''''''''''''''''''''''''''''     
            ''''''''''''''''''''''''''''''''''''
            ' SSE ITERATION LOOP
            ''''''''''''''''''''''''''''''''''''   
            ''''''''''''''''''''''''''''''''''''
            k = 0   
            ' 32 bit singles are only taking up 1/4 of these registers
            asm
                mov cx, 0
                movss xmm2, [ci]
                movss xmm3, [cr]
                 
                @starter:
             
                movss xmm0, [dx1]
                mulss xmm0, xmm0
                movss [z1], xmm0        'z1 =  dx1 * dx1
                               
                movss xmm1, [dy1] 
                mulss xmm1, xmm1   
                movss [z2], xmm1        'z2 =  dy1 * dy1               
                             
                addss xmm0, xmm1        ' z1 + z2     
               
                comiss xmm0,[bailnum]   ' if z1 + z2 > 2.0
                ja @asmdone                 
               
                inc cx                  ' handle the iterations counter
                cmp cx, 300
                je @asmdone
               
                movss xmm0, [dx1]
                movss xmm1, [dy1]
                mulss xmm0, xmm1        ' dy1 * dx1               
                addss xmm0, xmm0        ' (dy1 * dx1) + (dy1 * dx1)               
                addss xmm0, xmm2        ' + ci
                movss [dy1],xmm0        'dy1 = (dy1 * dx1) + (dy1 * dx1) + ci               
               
                movss xmm0, [z1]
                movss xmm1, [z2]
                subps xmm0, xmm1        ' z1 - z2               
                addss xmm0, xmm3        ' + cr
                movss [dx1],xmm0        'dx1 = z1 - z2 + cr   
               
             
                jmp @starter           
               
                @asmdone:
                mov [k],cx
            end asm
            '''''''''''''''''''''''''''''''''''''   
            '''''''''''''''''''''''''''''''''''''
            '''''''''''''''''''''''''''''''''''''
            if k = 300 then
                *p = 0
            else               
                *p = colSingle(k)
            end if
           
            ' print k, z3, dx1, dy1
            ' key = INKEY
            ' WHILE key = "": key = INKEY: WEND
            bail:
           
            p = p + 1
           
        next i
    next j
   
end sub




ptc_setdialog(1,"FullScreen?",0,0)
ptc_open( "tinyPTC Mandelbrot test", screenWidth, screenHeight )


'dim as string key
'print "Press to start"
'WHILE key = "": key = INKEY: WEND

init

dim as single t1,t2

t2 = timer
while inkey() <> chr(27)
   
    t1 = timer
   
    DrawMandelbrot
    ptc_update @buffer(0)
   
    print t1 - t2
   
Wend




6
R.I.P BOOGOP (getting some halloween correlation is really reaching!)

C#, .NET 4, VS2015, SharpMod for music, hopefully most folks will be able to run it without having to install a bunch of cruddy .NET which you probably wouldn't do anyway! No frameworks, only GDI with getpixel/putpixel [pointer] routines and bmp.drawstring. The drawback to doing things that 'oldskool' way is I have to limit the form size to get acceptable performance (particularly for the fractal zoomer), do my own sucky 3D, load my own textures [into int arrays] blahblah.

optimizing assumptions
- must have a doevents each time through the demo loop for the app to behave while rendering
- add is faster than mult (old assumption that may no longer be valid)
- bounds checking gets exponentially worse with 2-dim arrays so use multiples of 1 whenever possible
- switch is faster than if due to jumptable opcodes
- C# is optimized for doubles
- using pointers anywhere but the actual drawing would p-r-o-b-a-b-l-y be slower (much discussion on this exists)
- use bitwise ops whenever possible (&=, >>, <<)

Notes on some of the FX (I really need to get out of the early 90's, man)

FRACTAL ZOOMER
- my two problems with fractal zooming is the thing wants to spend longer and longer in the escape-time loop to get resolution at depth, and eventually you run into the limits of a double variable type. After I'd gotten the thing working I dug around in the IL and optimized it based on what I saw the compiler emitting, though I'm guessing on some of the commands (just for kicks I rewrote this in freebasic with ASM for the inner loop, SSE instruction set, and it was slow as crap. But it may be my retarded asm too)
XOR
- these are lulzy and look really oldskool if you live in the past like I do
BOBS
- there's a few of these in here for ball-0-ween lolz
DOT LANDSCAPE
- I'm really pleased with this, I worked the problems out of the one I used in my last demo and tweaked it until it looks close to 'fake demo' by Pelusa which I love
VECTOR BALLS
- The problem with these is whatever I do with them they usually end up looking like Tumblin's 94 demo unless you just bounce them around like Scoopex, but that was less interesting
TRIPLASMA
- I liked Argon by Matrix (1997), however this ain't that. I draw three plasmas on top of each other and skip the black values in the color array. What I've done is probably not a true tri-plasma and Argon seems to be doing some blending that eludes me. But even if I translated it directly it wouldn't look the same. STOSW in c# --> lololol
PLASMA CLOUDS
- a modification of the effect I used last time which drew the plasma then rotated the palette. This one attempts to do it in realtime by using values in arrays to redraw the map instead of getPixel each time which is a killer. For some reason this wants to migrate to the bottom right. Meh, palette rotation actually looks better.

CREDZ
skull graphic, palm tree and a few others from some public domain clipart collection I can't remember, openclipart maybe
Music is starlitdeception.mod by Necros. Dude was one of the best trackers ever
Font is some free thing but I call bmp.SetResolution(320, 200) which doesn't affect the actual drawing but causes the font to be rendered in glorious lo-res lol



7
I work in vs2015 c#,  which is a beautiful language,  but when you're stuck in the late 80s and early 90's and stupidly insist on doing everything yourself without frameworks it chafes. There is no getting away from GDI. Is it even possible to access the graphics hardware directly anymore without resorting to a framework?  I see a lot of acronyms going around,  which have you had experience with? Any support asm? Basically I'm feeling the itch for something lower level than current Microsoft technologies.

(and if there was any way it could resemble 'work' that would be a plus lol)

8
Here's my contribution to the Amiga anniversary compo!

Written in C#, .NET4, GDI+ only. No OpenGL, no DirectX. Just what I could do with getpixel/putpixel routines. Seemed fitting!

Back in the day some of the old demos required a pretty good PC to run. Now that PCs are blazingly fast it's brutally ironic that since I'm using just GDI SO DOES MINE!!! lol  :-[

It's a sad state of affairs that those old Amiga guys wrote their intros and cracktros in asm on primitive computers and what they did STILL LOOKS BETTER THAN MINE!  :clap: Respect!






9
Projects / App store approved my demo!
« on: April 07, 2011 »
(or demo-ish app) --> IntroFX

If you've got an iPhoan, go to the app store and it's under 'Entertainment.' Or search on 'IntroFX.' The app was originally titled 'DemoFX' but I scrubbed all references to 'Demo' due to Apple's cryptic guidelines against the word.

Notes:
- Scrolling checkerboard/floor: totally cheating. I use textures instead of calculating.
- Dot sphere: there's a perspective problem. Damned if I can figure it out
- Twisty bars: slower than hell due to iOS's miserable implementation of GL_POINTS, much worse on an iPad. I should have just taken it out.
- Plasma square: clipping problem I forgot to fix
- iPad: touches only work in the upper left quadrant, again due to retarded programmer :whack:

A word on the greets

va!n staticgerbil xalthorn dr.death - they responded to my original thread!
FC - though Future Crew hasn't been around for years, same with Kefrens, 2nd Reality and Desert Dream are still my favorite demos
Jare, Raphius,Denthor for their tutorials back in the day
Jeff Molofee because a lot of folks who code in openGL owe as much to him as the old scene owed to Michael Abrash
dbfinteractive - so you guys get blamed!  O0

So...some parts are a little glitchy but most work, and with the music and greets it should get the idea across.

10
General coding questions / iPhone Demo
« on: December 17, 2010 »
Longtime lurker here. I thought you guys might be interested in this--I'm finishing up a retro demo for the iPhone. To my knowlege this hasn't been done before, at least I've never seen a real demo in the app store. There are a couple showing demo type effects, but no real oldschool demo.

I'm doing this in Objective-C on a Mac mini. Obj-C is basically a wrapper for C, but contains enough Mac weirdness to make it a challenge. It takes a subset of OpenGL that doesn't offer quads or the predefined shapes in GLUT, so you have to do everything with lines, points or triangles. There are some good gaming libraries available like CocoaGL, but for me it's been easier to just write it using OpenGL directly.

I'm doing the music in Garageband, which ships with MacOS. It's pretty good and has a huge variety of samples and loops. Found something interesting though when I dragged one of my ancient MIDI compositions into it. Garageband understands MIDI and lets you redefine the voices for each track.

I'm including some of my favorite oldskool effects:
- parallax stars
- sphere
- free-direction dot tube
- dot tunnel
- texture-mapped tunnel
- plasma mapped onto a pyramid
- blobs mapped onto a cube
- dot grid
- terrain
- copper bars

The dot tunnel has actually been the biggest b*tch to figure out. I'm not including a lens effect or 3D starfield because those have been really overdone. I'd post this on the Obj-C sub-board but there isn't one! lol

TLM/Lathe

Pages: [1]