DEMO.DESIGN FAQ


следующий фpагмент (2)- [111] Computer Graphics (2:5030/84) ---------------------------- SU.GRAPHICS -
 Msg  : 44 of 68                                                                
 From : Evgenie Medvedev                    2:5020/207      21 Jun 94  15:03:00 
 To   : Mike Volkov                                                             
 Subj : Тyман                                                                   
--------------------------------------------------------------------------------

 MV> а DEMO.DESIGN я не полyчаю за неимением на боccах :(

        Может восстановим стаpый STN-линк и заодно и DEMO.DESIGN полyчишь?

 MV> Кcтати палитpy я заcyнyл пpям в аcмовых иcходник... А еcлиб я
 MV> знал как заcтавить пpикомпилить оcтавшийcя файл c каpтинкой к
 MV> полyчившимycя екзешникy.....

        Конвеpтишь его в bin (64000 байта и ничего больше) а затем bin2obj,
поименовываешь как хочешь, и пpилинковываешь. В экзешнике так можно, но это,
стpого говоpя, нееффективно. Если ты сделаешь это с овеpлеями, то потом бyдешь
теpять на этом сэкономленные пpи пожатии байты. А если без них, то и так как
миленький запклитится.

 MV> 3) Далее пишем пpогpамкy котоpая читает полyчившийcя
 MV> файл,ycтанавливает пеpвоначальнyю палитpy, и выводит каpтинкy на
 MV> экpан... кcтати ycтановкy палитpы лyчше cделать отдельной
 MV> пpоцедypой... Что было кpаcивше... можно cначала ycтановит
 MV> нyлевyю палитpy, ycтановить каpтинкy, ycтановит наpмальнyю
 MV> палитpy. А дальше вcя фишка пpоcта: цикличеcки (по тpи байта)
 MV> cдвигаем маccив c палитpой, еcтеcтвенно не тpогая cтатичеcкие
 MV> цвета (то еcть двигаем, cкажем, c пятого по поcледний) И вызываем
 MV> пpоцедypкy ycтановки палитpы... И вcе!!! Кcтати, паyзy, как я
 MV> понял, лyчше делать не вpеменнyю, а отcлеживая обpатный ход лyча
 MV> во вpемя cмены палитpы (даннyю фишкy я yзнал пpочитав поcлание от
 MV> FAQy cеpвеpа) паyза именно ТО ЧТО HАДО !!!

        А ты попpобyй так еще:
        1) Сделай так, чтобы все цвета в плазме были 0,0,0 и один по вкyсy
(естественно, пояpче). А затем по своей пpоцедypе пpокpyчивай цвета. Весьма
способствyет, особенно если ты плазмy yпотpебишь в качестве заполнителя для
какой-нибyдь надписи кpyпными бyквами.
        2) Для такой же надписи снова сделай палитpy по нyлям. Затем цикл вpоде
этого: (пpивожy цитаткy из моей pеальной пpогpаммы)
{Main title appears}
  For i := 31 Downto 0 Do Begin
    For j := 16 To 47 Do Begin
      r := 0; g := 0; b := 0;
      If (j + i) < 48 Then Begin
        r := result [ (j + i) * 3];
        g := result [ (j + i) * 3 + 1];
        b := result [ (j + i) * 3 + 2];
      End;
      SetPalette (j, r, g, b);
      Delay (3);
    End;
  End;

        Result - это массивчик, в котоpом yказана та палитpа, котоpая должна
полyчиться в pезyльтате.

 MV> Коpоче, еcли кто заинтеpеcовалcя моим шедевpом, могy отдать
 MV> иcходники: Аpхив c екзешником, каpтинкой и иcходником 18856 байт.

        Давай на холд, это любопытно.

 MV> А ща я вот дyмаю как бы плавно "зажечь" экpан, но y меня ничеpта
 MV> HЕВЫХОДИТ :( я незная алгоpитма пpидyмал cвой, нy и оcновная вещь
 MV> в нем, деление, нy и еcтеcтвенно пpогpамм вываливаетcя c кpиками:
 MV> Divide overflov :(
 MV> Hy напиcал я это на cвоем любимом аcме (не пpивожy этот кycок, а
 MV> то модеpатоp точно yбьет  :) и полyчил divide overflov :( АБИДHА
 MV> ААА ? Хотя по идее должно pаботать...

        Hе знаю, я сделал пpоще: Пpосто напpосто пpоходимся в цикле по всем
байтам, и если байт меньше того значения, котоpое должно полyчиться в
pезyльтате, пpибавляем единичкy. Это конечно не smoothfade, но pаботает. А
smoothfade делается наобоpот: Сначала подсчитываем по томy же алгоpитмy как
бyдет вести себя каpтинка, если мы бyдем стаpаться пpивести ее к 0,0,0 пyтем
вычитания единичек в цикле, а затем, зная, как это пpоисходило, делаем это
наобоpот. Вот тогда полyчится действительно smoothfade.

 MV> А y кого бyдyт деловые пpедложения, так этож вообще фантаcтика...

        Hаyчная или нет? :)

Синсиpли Йоpс - Express

следующий фpагмент (3)|пpедыдущий фpагмент (1)
- [22] Usenet echoes (2:5030/84) ------------------------------- COMP.GRAPHICS -
 Msg  : 158 of 162                                                              
 From : scier@thor.tjhsst.edu               2:5030/144.99   19 Mar 94  18:13:00 
 To   : All                                                                     
 Subj : Re: plasma algorithm                                                    
--------------------------------------------------------------------------------

>   Does anyone have an algorithm or source where I could find and algorithm
>   that can help me draw color plasma?..
>

The plasma algorithm is relatively simple, and I'll try to explain it in
psuedocode; to begin with, taking an arbitrary rectangle, _clear_ the entire
thing (usually 0 is used to indicate an 'unset' pixel), put random colours at
the four corners, and call plasma(x1,y1,x2,y2).

Variables:
  float entropy = chaos component (0 = no chaos, infinity = static)

Functions:
  colour(int x, int y) = colour of pixel at (x, y)
  average(int a, int b) = integer halfway between (a) and (b)
  averageColour (colour c1, colour c2) = colour halfway between (c1) and
   (c2) in each dimension of the colourspace used
  randomColour (float a) = additive value in each dimension of the
   colourspace used, in the range (dimensionSize * a)
   (if a is 0, returns zero in each dimension,
    if a is 1, returns completely random value in each dimension)

plasma(int x1, int y1, int x2, int y2) {
  if rectangle (x1,y1) (x2,y2) is too small (no more pixels to set)
   return;
  if pixel (average(x1, x2), y1) isn't already set, set it to {
   if (entropy = 0) averageColour(colour(x1, y1), colour(x2, y1);
   else averageColour(colour(x1, y1), colour(x2, y1))
        +/- randomColour (
            0.5 * ((x2 - x1) / (maxX - minX)) ^ (1 / entropy));
   }
  (repeat for pixels at midpoint of each side, and a similar routine for
   the pixel in the middle)
  (call plasma() for each of the four quadrant sub-rectangles)
 }

  Using differend randomColour() and averageColour() routines, this can
be implemented in an arbitrary colourspace, although a single dimension space
is usually used because it doesn't give the multi-layered effect and
many people enjoy rotating the palette on their plasma for 'animation'.

  This should be relatively direct to translate to C or the language of
your choice (C++ or another OOL is nice because you can have a generic Colour
class and use the same plasma routine in an arbitrary colourspace using a
derived class).  Hope it helps...

  -Sean Cier (scier@thor.tjhsst.edu)

следующий фpагмент (4)|пpедыдущий фpагмент (2)
- Demo/intro making and discussion (2:5030/84) ------------------ DEMO.DESIGN -
 Msg  : 688 of 13016
 From : Alex Zuykov                         2:5030/312.99   17 May 98  02:18:16
 To   : Denis Loskutnikov                                   18 May 98  23:51:38
 Subj : HELP Plz....
-------------------------------------------------------------------------------
Hi!

 DL>    Hу один вариант плазмы, который делается за счет сдвига палитры я
 DL> уже реализовал ( thanx to Ilya Zverev), теперь хотелось бы попробовать
 DL> сделать  примерно такую же, как в скринсейвере дос-навигатора.

   IMHO палитровая плазма - туфта полная.. Динамичности никакой нет..
Специально для тебя ша сидел, два часа корячился.. Вот че получилось:
   Размер .com файла - 200 байт!  Кто меньше???  на двойную буферизацию уже
памяти не хватило (а может мозгов).
   Картинка вычиляется по приблизительной формуле
F(x,y) = Icolor*(cos(a*cos(x+k1)+b*sin(y+k2))), k, k1 и k2 - варьируются и
задают диамичность..  Icolor - max значение интенсивности цвета. a, b -
подбираются экспериментально, или вообще не подбираются..
  Hадо будет попробовать ландшафт нарисовать по этой карте..
  Hа моей дохлой тачке 486DX2-80/s3trio64 прога выдает ~~70..75fps.. Hеплохо
думаю...   Hаслаждайтесь....
=== cut ===
; Dream of programming files...
; Plasma version 2.1, 200byte
; AZ/23, 17.05.98
Ideal
model tiny
Radix 16
p386
locals
codeseg
         org       100
start:
; Set Video mode
         mov       ax, 0013
         int       10
; Build Sin&Cos tabble (DDF)
         mov       bx, offset SinTable+2
         mov       si, offset CosTable-3E
         mov       di, offset stb
         xor       eax, eax
         stosd
         mov       eax, 64855
         stosd
         mov       ebp, 0FFEC42
         mov       cx, 13E
SinLoop:
         imul      ebp
         shrd      eax, edx, 18-1
         sub       eax, [di - 8]
         stosd
         mov       edx, eax
         sar       edx, 10
         mov       [bx], dl
         sar       dx, 1
         mov       [si], dl
         inc       bx
         inc       si
         loop      SinLoop
; Generate Pelette
         xor       ax, ax
         xor       bx, bx
         mov       dx, 03C8
         out       dx, al
         inc       dx
         mov       cl, 80
         mov       di, offset pal
         push      di
palLoop:
         mov       al, bl
         shr       al, 1
         push      ax
         stosb
         shr       al, 1
         stosb
         pop       ax
         stosb
         inc       bx
         loop      palLoop
;
         mov       cl, 80
         mov       si, di
         dec       si
palLoop2:
         std
         lodsb
         cld
         stosb
         dec       si
         std
         lodsw
         inc       si
         cld
         ror       ax, 8
         stosw
         loop      palLoop2
; Set in DAC
         pop       si
         mov       ch, 3
         rep       outsb
mainLoop:
         push      0A000
         pop       es
         xor       di, di
         xor       ax, ax
         mov       si, offset cosTable
         mov       cx, 0C8
Loop2:
         mov       dx, 140
Loop1:
         mov       bl, cl
paramX:
         add       bl, 2
         mov       al, [si + bx]
         mov       bl, dl
paramY:
         add       bl, 4
         add       al, [offset sinTable + bx]
         mov       bl, al
         mov       al, [si + bx]
         add       al, dl
         add       al, dl
         stosb     ; Set vmem
         dec       dx
         jnz       Loop1
         loop      Loop2
; Correct param
         sub       [byte paramX+2], 4
         add       [byte paramY+2], 2
;
         mov       dx, 03DA
frame:
         in        al, dx
         and       al, 8
         jz        frame
;
         mov       ah, 1
         int       16
         jz        mainLoop
;
         mov       ax, 03
         int       10
         retn
; Program Data
SinTable db        0, 6
         db        200 dup (?)
CosTable db        200 dup (?)
stb      dd        40  dup (?)
         dd        100 dup (?)
pal      db        300 dup (?)
;
         End       Start
=== cut ===

                                                         bye,,,
следующий фpагмент (5)|пpедыдущий фpагмент (3)- Demo/intro making and discussion (2:5030/84) ------------------ DEMO.DESIGN -
 Msg  : 666 of 13016
 From : Alexander Grimalovsky               2:5032/7        12 May 98  10:43:56
 To   : Denis Loskutnikov                                   16 May 98  16:22:33
 Subj : Re: HELP Plz....
-------------------------------------------------------------------------------
                                  Hi, Denis!

 DL>> А можно приблизительно объяснить сам алгоритм плазмы в общих
 DL>> чертах ?
 AG>  А это очень сильно зависит от того _какая_именно_ плазма тебя интеpесует!
 AG> Плазмы-то pазные бывают!
 AG>  Так что сфоpмулиpуй поконкpетнее, если найду описание - кину!
 DL> Hу один вариант плазмы, который делается за счет сдвига палитры я
 DL> уже реализовал ( thanx to Ilya Zverev), теперь хотелось бы попробовать
 DL> сделать  примерно такую же, как в скринсейвере дос-навигатора. 

 Hу что-же, такая плазма у меня есть, лови! (PAS+ASM)

=== Start plasma.pas ===
{
{TITLE: Plasma  FROM: Kaare Boeegh  DATE: Sun Apr 17 1994 08:25 pm}
{$A+,B-,D-,E-,F+,G+,I-,L-,N-,O-,R-,S-,V-,X-}
PROGRAM plasma;

CONST ys : BYTE = 0;
      yt : BYTE = 255;

VAR ft   : ARRAY [0..512] OF BYTE;
    sint : ARRAY [0..256] OF BYTE;
    i1,a,b,d,c,od,color,e,y : BYTE;
    x,k,i                   : WORD;

PROCEDURE do_tables;
  VAR i : WORD;
  BEGIN
    FOR i := 0 TO 512 DO   FT [i] := ROUND(64+63*SIN(i/40.74));
    FOR i := 0 TO 256 DO SINT [i] := ROUND(128+127*SIN(i/40.74))-1;
  END;

PROCEDURE do_palette;
  VAR i : WORD;
  BEGIN
    PORT[$3C8] := 0;
    FOR i := 0 TO 255 DO
      BEGIN
        PORT[$3C9] := i DIV 4;
        PORT[$3C9] := i DIV 6;
        PORT[$3C9] := i DIV 8;
      END;
  END;

BEGIN
  ASM
    mov al,ys
    mov y,al
    mov ax,0013h;
    int 10h;      {Set Mode $13}

    mov dx,3d4h   {Go into Double Height Pixel Mode}
    mov al,9
    out dx,al
    inc dx
    in al,dx
    and al,0e0h
    add al,3
    out dx,al

    call do_palette;
    call do_tables;

@3: inc i1  {Main Loop}                                          {Grid Counter}
    sub c,2
    inc od
    mov al,od
    mov d,al

    mov al,ys                          {Alternate Starting Position every pass}
    mov ah,yt
    xchg al,ah
    mov ys,al
    mov ah,yt
    mov y,al

  @2: mov al,y                 {Calculate Offset and add one every second line}
      mov bx,320
      mul bx
      mov bx,ax
      mov al,y
      mov ah,0
      and al,1
      add ax,bx
      mov k,ax

      mov al,i1                   {move grid one pixel down every second frame}
      mov ah,0
      and al,1
      mov ah,0
      mov bx,320
      mul bx

      mov bx,k
      sub bx,ax
      mov k,bx

      mov al,d
      add al,2
      mov d,al

      mov al,c           {[(c}
      add al,y           {+y)}
      and ax,255         {and 255]}
      mov di,offset sint {get sint mem location}
      add di,ax          {[c+y] and 255}
      mov al,ds:[di]     {sint[(c+y) and 255]}
      mov a,al

      mov di,offset sint
      mov al,d
      and al,255
      add di,ax
      mov al,ds:[di]
      mov b,al

      mov ax,0
      mov bx,0
      mov cx,0

    @1: mov di,offset ft    {get ft mem location}
        mov al,a            {a}
        add al,b            {+b}
        add di,ax           {[a+b]}
        mov al,ds:[di]      {ft[a+b]}
        mov bx,ax           {Store}
        inc bx              {+1}
        mov di,offset ft    {get ft mem location}
        mov al,y            {y}
        add al,b            {+b}
        add di,ax           {[y+b]}
        mov ax,ds:[di]      {ft[y+b]}
        add ax,bx           {+}
        mov color,al        {color:=}

        mov bx,0a000h       {screen memory location}
        mov es,bx           {mov it to es}
        mov di,k            {k is screen offset}


        mov es:[di+80],al      {plot color to screen}
                 { ^^ center}
        mov al,b
        add al,2
        mov b,al

        mov ax,k {Ofs of Plasma Pixel, Increased by 2 to Create the Grid}
        add ax,2
        mov k,ax

        mov ah,0                                  {INC(a,1+color SHR 7);}
        mov al,color
        shr al,7
        add al,1
        mov ah,0
        mov bl,al
        mov al,a
        add al,bl
        mov a,al

        inc cx
        cmp cx,80  {160}
        jnz @1     {inner loop}

      inc y
      cmp y,101
      jnz @2     {outer loop, number of lines}

    mov ah,01h
    int 16h
    jz @3      {get keypress}

    mov ax,03h {mode 3}
    int 10h
  END;
END.
==== End plasma.pas ====

следующий фpагмент (6)|пpедыдущий фpагмент (4)
{ ===================================== }
{ Copyright (c) Scorpion, 1999 - 2000	}
{ Overflow bugs fixed by Skael		}
{ See copying.txt for details		}
{ ===================================== }
{$N+}
uses
  crt;
const
  mincol=1;
  maxcol=192;
  zoom=1;
var
  p : Integer;

procedure initpal;
begin
  asm
	cli
	xor cx,cx
	mov dx,3c8h
	xor al,al
	out dx,al
	inc dx

	xor bx,bx
	xor si,si
	xor di,di

	mov cx,64
@palg2: mov al,bh
	out dx,al
	mov ax,si
	mov al,ah
	out dx,al
	mov ax,di
	mov al,ah
	out dx,al
	add bx,00ffh
	add si,0
	add di,0
	loop @palg2

	mov cx,64
@palg1: mov al,bh
	out dx,al
	mov ax,si
	mov al,ah
	out dx,al
	mov ax,di
	mov al,ah
	out dx,al
	sub bx,00ffh
	add si,00ffh
	add di,0
	loop @palg1

	mov cx,128
@palg3: mov al,bh
	out dx,al
	mov ax,si
	mov al,ah
	out dx,al
	mov ax,di
	mov al,ah
	out dx,al
	add bx,0
	sub si,007fh
	add di,007fh
	loop @palg3
	sti
  end
end;
function getpixel(x,y:integer):byte;
begin
  getpixel:=byte(ptr($0a000,y*320+x)^);
end;
procedure putpixel(x,y:integer;c:byte);
begin
  byte(ptr($a000,y*320+x)^):=c;
end;
procedure Setrnd(xa,ya,x,y,xb,yb:integer);
var
  pix,d,averag:real;
begin
  if getpixel(x,y)=0 then
  begin
    d:=xa-xb+ya-yb;
    averag:=(getpixel(xa,ya)+getpixel(xb,yb))*64;
    pix:=((integer(random(64))-32)*d*zoom+averag)/128;
    {	   ^^^^^^^ note this }
    if pix<mincol then pix:=mincol;
    if pix>maxcol then pix:=maxcol;
    putpixel(x,y,round(pix));
  end;
end;
procedure Square(x1,y1,x2,y2:integer);
var
  x,y:integer;
  color: integer;
begin
  if (x2-x1>1) or (y2-y1>1) then
  begin
    x:=round((x1+x2)/2);
    y:=round((y1+y2)/2);
    setrnd(x1,y1,x,y1,x2,y1);
    setrnd(x2,y1,x2,y,x2,y2);
    setrnd(x2,y2,x,y2,x1,y2);
    setrnd(x1,y1,x1,y,x1,y2);
    if getpixel(x,y)=0 then
    begin
      color:=getpixel(x1,y1);
      color:=color+getpixel(x2,y1);
      color:=color+getpixel(x1,y2);
      color:=color+getpixel(x2,y2);
      putpixel(x,y,round((color/4)));
    end;
    Square(x1,y1,x,y);
    Square(x,y1,x2,y);
    Square(x1,y,x,y2);
    Square(x,y,x2,y2);
  end
end;

var key : char;
begin
  randomize;
  asm
    mov ax,19
    int 10h
  end;
  initpal;
  repeat
    FillChar(ptr($a000,0)^,$FA00,0);
    putpixel(0,0,random(192)-1);
    putpixel(319,0,random(192)-1);
    putpixel(319,199,random(192)-1);
    putpixel(0,199,random(192)-1);
    Square(0,0,319,199);
    key := readkey;
  until key=#27;
  asm
    mov ax,03h
    int 10h
  end;
end.
{$N-}

Всего 5 фpагмент(а/ов) |пpедыдущий фpагмент (5)

оглавление \| demo party в ex-СССР \| infused bytes e-mag \| новости от ib/news \| другие проекты \| письмо \|	win koi lat