Subversion Repositories Kolibri OS

#include "ati2d.h"

#include "accel_2d.h"

void STDCALL (*SetHwCursor)(cursor_t*,int x,int y)__asm__("SetHwCursor");

void STDCALL (*HwCursorRestore)(int x, int y)__asm("HwCursorRestore");

cursor_t* IMPORT (*HwCursorCreate)(void)__asm("HwCursorCreate"); //params eax, ebx, ecx

void (__stdcall *old_set)(cursor_t*,int x,int y);

void (__stdcall *old_restore)(int x, int y);

cursor_t* (*old_create)(void);

cursor_t* __create_cursor(void);

{

  RHDPtr rhdPtr;

  u32 retval;

    return 0;

  {

     printf("Can't open /rd/1/drivers/ati2d.log\nExit\n");

     return 0;

  }

  {

    dbgprintf("Device not found\n");

    return 0;

  };

  {

    if(rhd.memBase[i])

      dbgprintf("Memory base_%d 0x%x size 0x%x\n",

                i,rhd.memBase[i],(1<

  };

  for(i=0;i<6;i++)

  {

    if(rhd.ioBase[i])

      dbgprintf("Io base_%d 0x%x size 0x%x\n",

                i,rhd.ioBase[i],(1<

  };

  if(!RHDPreInit())

    return 0;

//  old_set = SetHwCursor;

//  old_restore = HwCursorRestore ;

//  old_create = HwCursorCreate;

  rhd.has_tcl = 1;

  Init3DEngine(&rhd);

 // SetHwCursor     = r500_SetCursor;

 // HwCursorCreate  = __create_cursor;

 // HwCursorRestore = r500_CursorRestore;

  dbgprintf("reg service %s as: %x\n", "HDRAW", retval);

  return retval;

};

{

  u32 *inp;

  u32 *outp;

  outp = io->output;

  {

    case SRV_GETVERSION:

      if(io->out_size==4)

      {

        *(u32*)io->output = API_VERSION;

        return 0;

      }

      break;

      return ERR_PARAM;

  };

  return ERR_PARAM;

}

{

  u32 *inp;

  u32 *outp;

  outp = io->output;

  {

    case SRV_GETVERSION:

      if(io->out_size==4)

      {

        *outp = API_VERSION;

        return 0;

      }

      break;

        if(io->inp_size==6)

          return DrawRect((draw_t*)inp);

        break;

        if(io->inp_size==9)

          return FillRect((fill_t*)inp);

        break;

        if(io->inp_size==5)

          return Line2P((line2p_t*)inp);

        break;

        if(io->inp_size==6)

          return Blit((blit_t*)inp);

        break;

        if(io->inp_size==6)

          return RadeonComposite((blit_t*)inp);

        break;

        if(io->inp_size==6)

          return CreatePixmap((userpixmap_t*)inp);

        break;

        if(io->inp_size==8)

          return PixBlit((pixblit_t*)inp);

        break;

        if(io->inp_size==6)

          return LockPixmap((userpixmap_t*)inp);

        break;

      return ERR_PARAM;

  };

  return ERR_PARAM;

}

#include "pci.c"

#include "ati_mem.c"

//#include "cursor.inc"

#include "accel_2d.inc"

#include "accel_3d.inc"

#define CLIP_BOTTOM     2

#define CLIP_RIGHT      4

#define CLIP_LEFT       8

/*=================================

{

    char            flag;

    if( x < clip.xmin ) {

        flag |= CLIP_LEFT;

    } else if( x > clip.xmax ) {

        flag |= CLIP_RIGHT;

    }

    if( y < clip.ymin ) {

        flag |= CLIP_TOP;

    } else if( y > clip.ymax ) {

        flag |= CLIP_BOTTOM;

    }

    return( flag );

}

/*===========================================================================

    (x1, y1) is outside and ( x2, y2 ) is inside the viewport.

    NOTE : the signs of denom and ( x - *x1 ) cancel out during division

           so make both of them positive before rounding.   */

{

    int            numer;

    int            denom;

    numer = 2L * (long)( y2 - *y1 ) * abs( x - *x1 );

    if( numer > 0 ) {

        numer += denom;                     /* round to closest pixel   */

    } else {

        numer -= denom;

    }

    *y1 += numer / ( denom << 1 );

    *x1 = x;

}

/*=============================================================

    viewport using the Cohen-Sutherland clipping algorithm. Return the

    clipped coordinates and a decision drawing flag.    */

{

    char            flag1;

    char            flag2;

    flag2 = _L1OutCode( *x2, *y2 );

    for( ;; ) {

        if( flag1 & flag2 ) break;                  /* trivially outside    */

        if( flag1 == flag2 ) break;                 /* completely inside    */

        if( flag1 == 0 ) {                          /* first point inside   */

            if( flag2 & CLIP_TOP ) {

                line_inter( y2, x2, *y1, *x1, clip.ymin );

            } else if( flag2 & CLIP_BOTTOM ) {

                line_inter( y2, x2, *y1, *x1, clip.ymax );

            } else if( flag2 & CLIP_RIGHT ) {

                line_inter( x2, y2, *x1, *y1, clip.xmax );

            } else if( flag2 & CLIP_LEFT ) {

                line_inter( x2, y2, *x1, *y1, clip.xmin );

            }

            flag2 = _L1OutCode( *x2, *y2 );

        } else {                                    /* second point inside  */

            if( flag1 & CLIP_TOP ) {

                line_inter( y1, x1, *y2, *x2, clip.ymin );

            } else if( flag1 & CLIP_BOTTOM ) {

                line_inter( y1, x1, *y2, *x2, clip.ymax );

            } else if( flag1 & CLIP_RIGHT ) {

                line_inter( x1, y1, *x2, *y2, clip.xmax );

            } else if( flag1 & CLIP_LEFT ) {

                line_inter( x1, y1, *x2, *y2, clip.xmin );

            }

            flag1 = _L1OutCode( *x1, *y1 );

        }

    }

    return( flag1 & flag2 );

}

/*======================================================

{

    if( flag & CLIP_TOP ) {

        *y = clip.ymin;

    } else if( flag & CLIP_BOTTOM ) {

        *y = clip.ymax;

    } else if( flag & CLIP_RIGHT ) {

        *x = clip.xmax;

    } else if( flag & CLIP_LEFT ) {

        *x = clip.xmin;

    }

}

/*==============================================================

    active viewport based on the Cohen-Sutherland algorithm for line

    clipping. Return the clipped coordinates and a decision drawing

    flag ( 0 draw : 1 don't draw ). */

{

    char            flag1;

    char            flag2;

    flag2 = _L1OutCode( *x2, *y2 );

    for( ;; ) {

        if( flag1 & flag2 ) break;                  /* trivially outside    */

        if( flag1 == flag2 ) break;                 /* completely inside    */

        if( flag1 == 0 ) {

            block_inter( x2, y2, flag2 );

            flag2 = _L1OutCode( *x2, *y2 );

        } else {

            block_inter( x1, y1, flag1 );

            flag1 = _L1OutCode( *x1, *y1 );

        }

    }

    return( flag1 & flag2 );

}

typedef struct

{

   int left;

   int top;

   int right;

   int bottom;

}rect_t;

{

   struct _window *fd;

   struct _window *bk;

   int width;

   int height;

}win_t, *WINPTR;

WINPTR bottom = NULL;

{

    WINPTR pwin = malloc(sizeof(win_t));

};

{

   WINPTR pwin = alloc_window();

   pwin->pos.top    = t;

   pwin->pos.right  = l+w-1;

   pwin->pos.bottom = t+h-1;

   pwin->width      = w;

   pwin->height     = h;

};

{

   WINPTR p = top;

   {

     if(pwin->level <= p->level)

     {

        pwin->fd = p;

        pwin->bk = p->bk;

        pwin->bk->fd = pwin;

        p->bk = pwin;

     }

     else

       p = p->fd;

   }

   else

     top = pwin;

}

>