
 XvCgAyу|SɊւ֐ɂ

Bool slWindow(Sint16 Left,Sint16 Top,Sint16 Right,Sint16 Bottom,Uint16 Zlimit,
		Sint16 CentX,Sint16 CentY)

  @\ : XvCgAyу|S̕\𐧌͈͂ݒ肵܂B
	 \͈͂ TV ʏł̈ʒuŁA\ɂQ܂Ŏwł܂B
	 Zlimit  悪\ȂȂ܂B
	 CentX , CentY  |Sł͏_̈ʒuAXvCgł͍W_
	 Ȃ܂B
	 ʏł̈ʒu͍オ(O,O)AE(RPX,QQR) <ʏʃTCY>
	 łB

   : slWindow()  ĂԑO slPutPolygon() , slPutSprite() ̃XvCg
	 Zbg֐gpƁAɂ͑SʃTCỸEBhEg
	 pA߂ČĂ΂ꂽ slWindow() Őݒ肳EBhEڂɂ
	 ܂B
	 ʏ
		slWindow(...) ;		/* Window 1 */
		    ...
		  slPutPolygon(...) ;
		  slPutSprite(...) ;
		    ...
		slWindow(...) ;		/* Window 2 */
		    ...
		  slPutSprite(...) ;
		  slPutPolygon(...) ;

	 ̂悤ɁÂ͂߂ɃEBhEZbgAؑւłx
	 ʂ̃EBhEZbg悤ɂ܂B


void slPerspective(ANGLE pers)
  @\ : ϊ鎞Ɏgp XN[܂ł̋萔ݒ肵܂B
	 ]XN[̉]Syʒuݒ肵܂B
	 p̓XN[̉(EBhẼTCYł͂Ȃ)Ɏ삪px
	 Ďgp܂B

void slLight(VECTOR light)
  @\ : ̕ݒ肵܂B
   : ͕sŁÂ݂\܂AxNg͒PʃxNgłȂ
	 ΂܂B傫PzꍇAI[o[t[܂̂ŁA
	 \ł܂(ȃJ[ŕ\܂)B
	 ܂Af\Ƃ slScale() gpĂ @l
	 XP[OĂ܂߁AI[o[t[Ă܂ꍇ܂
	 ̂ŁAXP[OȂ悤ɂĉB

Bool slZdspLevel(Uint16 level)
  @\ : XN[Oɂ|S(邢̓XvCgf[^)ǂ
	ŕ\̂؂ւ܂B
	level ͂PAQAR̂ꂩŁAȊO̓G[ɂȂ܂B
	P: XN[܂ł̋̂P/Q܂ł\͈͂ɂ܂(default)B
	Q: XN[܂ł̋̂P/S܂ł\͈͂ɂ܂B
	R: XN[܂ł̋̂P/W܂ł\͈͂ɂ܂B
	x؂ւƂȍ~ɕ\|S(邢̓XvCg)
	΂āAslWindow Ŏw肵Zlimit̊ʒulɕω܂̂ŁA
	ӂĉB

Bool slPutPolygon(PDATA *pat)
  @\ : Jg}gNXgpė^ꂽ|Sf]Esړ
	 AϊsȂA|SyсAό`XvCgƂĕ\܂B

Bool slPutPolygonS(PDATA *pat)
  @\ : Jg}gNXgpė^ꂽ|Sf]Esړ
	 AϊsȂA|SyсAό`XvCgƂĕ\܂B
   : L slPutPolygon() ֐ł́AX[ubot̏󋵂ɉď
	 SA}X^[botƕs܂A{֐ł́ASĂX[u
	 bots܂B

Bool slDispSprite(FIXED pos[XYZS] , ATTR *atrb , ANGLE Zrot)
  @\ : |WVAXP[A]pw肵AXvCg\܂B
	 slPutPolygon() Ɠl Zlɂ\[eBO܂B
	 XP[Ƀ}CiX̒lw肵ꍇAy|WVɂXP[Z
	 oAXP[̕␔|A\p̃XP[Ƃ܂B
	 Ⴆ΁AXP[Ɂ|Q.Ow肵ꍇAO.T{ŕ\悤Ȉ
	 u(y|WV)ɂ΁AP.O{ɂȂĕ\܂B

Bool slDispSpriteHV(FIXED pos[XYZSS] , ATTR *atrb , ANGLE Zrot)
  @\ : cA̕\XP[w肵āAό`XvCg\܂B
	 L slDispSprite() ֐ƈقȂAXP[Ƀ}CiXw肵ꍇ
	 LN^[͔]ĕ\܂B

Bool slDispSpriteSZ(FIXED pos[XYZSS] , ATTR *atrb , ANGLE Zrot)
  @\ : cA̕\TCYw肵āAό`XvCg\܂B
	 TCYɃ}CiXw肳ꂽꍇɂ́A]ĕ\܂B

Bool slDispSprite4P(FIXED pos[4][XY] , FIXED zpos , SPR_ATTR *atrb)
  @\ : ʏ̂S_w肵āAό`XvCg\܂B
	 S_̓EBhESɑ΂ItZbgʒuŎw肵AŜ\
	 yʒuʂɎw肵܂B
	 S_͍AEAEȀ(v)Ŏw肵܂B

Bool slPutSprite(FIXED pos[XYZS] , ATTR *atrb , ANGLE Zrot)
  @\ : Jg}gNXgpă|WVZoAϊɍ킹ăX
	 P[OꂽXvCg\܂B
	 L slDispSprite() Ɠ悤 w肳ꂽXP[{܂A
	 }CiXw肵ꍇA]ăXP[O܂B

Bool slSetSprite(SPRITE parms[] , FIXED Zpos)
  @\ : n[hEGAɓnXvCgRg[R}hf[^]Xg
	 Zbg܂B
	 Cu֐ł͍쐬łȂ悤ȕό`XvCgÃXvC
	 gɂ̂݉eEBhE̐ݒꍇȂǂɎgp܂B

Bool slDispPolygon(PDATA *pat , Uint16 mode)
  @\ : Jg}gNXgpė^ꂽ|Sf]Esړ
	 Aê܂܁A|SyсAό`XvCg\܂B
	 AvZANbsÕIvV͎gpł܂B
	 mode  Agr[g𑍂Ẵ|SL邩ǂ̃tOŁA
	 O̎AAgr[ge[u̐擪̃f[^ŁAe|S\
	 ܂BȊȌꍇɂ͎w肳ꂽAgr[gf[^ŕ\܂B

Bool slPutObject(OBJECT *objptr)
  @\ : w肳ꂽIuWFNg\̂Ŏw肳ꂽsړA]AXP[O
	 sȂA|Sf\܂B{֐͈ȉ̊֐s
	 ̂ƓʂƂȂ܂B

    void slPutObject(OBJECT *objptr){
	slTranslate(objptr->pos[X] , objptr->pos[Y] , objptr->pos[Z]) ;
	slRotZ(objptr->ang[Z]) ;
	slRotY(objptr->ang[Y]) ;
	slRotX(objptr->ang[X]) ;
	slScale(objptr->scl[X] , objptr->scl[Y] , objptr->scl[Z]) ;
	if(objptr->pat != NULL){
	    slPutPolygon(objptr->pat) ;
	}
    }

   : {֐̓Jg}gNXύX܂̂ŁAKvɉslPushMatrix()
	 ֐să}gNX̑ޔsȂĉB
	 ܂AIuWFNg̐eq֌WɂĂ̓[U[֐őΉĉB

  eq\ɂ\̃TvvO

	void PutAll(OBJECT* obptr){
	    slPushMatrix() ;			/* ẽ}gNXޔ */
	    {
		slPutObject(obptr) ;		/* IuWFNg̕\ */
		if(obptr->child != NULL){
		    PutAll(obptr->child) ;	/* qΕ\ */
		}
	    }
	    slPopMatrix() ;

	    if(obptr->sibling != NULL){
		PutAll(obptr->sibling) ;	/* ZIuWFNg̕\ */
	    }
	}

void slCurWindow(Uint8 win)
  @\ : \EBhE؂ւ܂B
	 win ɂ winFar () , winNear (O) ̂ꂩw肵܂B
	 {֐sƁAXN[ʒuA\̈悪ݒ肳܂A
	 xNg͕ύX܂̂ŁAӂĉB

Uint8 slSprWinNum()
  @\ : \ɎgpĂEBhEԍԂ܂B

void slFrameClipSize(Sint16 xsz , Sint16 ysz)
  @\ : XvCg\֐[ slDispSprite() , slPutSprite()] ƁAUseClip I
	 vVw肵|S\͈͂ݒ肵܂B
	 EBhETCYɑ΂A㉺Eɂꂼw肳ꂽ̈
	 Oꂽ_ɑ΂\Ƃ܂B

void slSetScreenDist(FIXED dist)
  @\ : ϊ鎞Ɏgp XN[܂ł̋萔ݒ肵܂B
	 ]XN[̉]Syʒuݒ肵܂B

void slGetFrameData(void* dst , Uint16 xsz , Uint16 ysz)
  @\ : t[obt@̓e(Pʕ)ǂݏoAw肳ꂽTCY
	 XP[O(Ԉ)ăZbg܂B
	 ShbgPʂŏĂ̂ŁAwTCY͂S̔{Ƃ܂B
	 obt@ɂ͒𑜓x̏ꍇQoCg/hbgA𑜓x̏ꍇPoCg/
	 hbgŁA݂܂B
	 ǂݏof[^XvCgƂĕ\ꍇɂ́A
    𑜓x:
	slSpriteColMode(SPR_PAL_RGB) ;	/* default */
    ƂA
	SPR_ATTRIBUTE(PN_???,No_Palet,No_Gouraud,SPdis|ECdis|CL32KRGB,sprNoflip) ;
    ƂAgr[gŃXvCg\֐s܂B

    𑜓x̏ꍇɂ
	slSpriteColMode(SPR_PAL) ;

	SPR_ATTRIBUTE(PN_???,No_Palet,No_Gouraud,SPdis|ECdis|CL256Bnk,sprNoflip) ;
    ̃Agr[gŕ\܂B

   : ̊֐ł͂ucoP̕`I҂At[obt@΂ǂ
	 āAobt@ɃZbgĂ܂Bt[obt@̓ǂݏoɂ͂
	 Ȃ̃EFCg邽߁ARQQS(=VUW)hbgłT.
	 x̎Ԃ̂ŁAԂɒӂĎgpĉB
	 ǂݍރobt@[NɂƂAuLOłuq`lɓ]
	 Aڂuq`lɓWJ̓EFCgȂ悤łB


 |S̃f[^ɂ

  slPutPolygon() Ŏgp|Sf[^͈ȉ̃tH[}bgɂȂĂ܂B

    .data.l	point_tbl	; _W̃e[u
    .data.l	NbPoint		; vZ钸_̐
    .data.l	polygon_tbl	; e|S̖@xNgƒ_ԍ̃e[u
    .data.l	NbPolygon	; vZ|S̐
    .data.l	attribute_tbl	; e|S̃Agr[g̃e[u

point_tbl:
    .data.l	X,Y,Z		; _ԍO̍Wf[^
    .data.l	X,Y,Z		; _ԍP̍Wf[^
	...
    .data.l	X,Y,Z		; _ԍ NbPoint - 1 ̍Wf[^

    bŃe[u쐬ꍇAPOINT^錾ĂAPOStoFIXED
    }Ngp邱ƂŁAL̃f[^e[u쐬邱Ƃł܂B
  )
	static POINT point_CUBE[] = {
	    POStoFIXED(-80,-80,-80) ,
	    POStoFIXED( 80,-80,-80) ,
	    POStoFIXED( 80, 80,-80) ,
	    POStoFIXED(-80, 80,-80) ,

	    POStoFIXED( 80,-80, 80) ,
	    POStoFIXED(-80,-80, 80) ,
	    POStoFIXED(-80, 80, 80) ,
	    POStoFIXED( 80, 80, 80)
	} ;

polygon_tbl:
    .data.l	Nx,Ny,Nz	; |SԍO̖@xNg
    .data.w	P0,P1,P2,P3	; |SԍOŎgp钸_̔ԍ
	(Op`̃|S̏ꍇAP2  P3 ԍɂȂ)
	...
    .data.l	Nx,Ny,Nz	; |Sԍ NbPolygon - 1 ̖@xNg
    .data.w	P0,P1,P2,P3	; |Sԍ NbPolygon - 1 Ŏgp钸_
				; ԍ

    bŃe[u쐬ꍇAPOLYGON^錾ĂAPOStoFIXED
    }Ngp邱ƂŁAL̃f[^e[u쐬邱Ƃł܂B
  )
	static POLYGON polygon_CUBE[] = {
	    {POStoFIXED( 0 , 0 ,-1) , { 0 , 1 , 2 , 3}} ,
		|__ |__
	    {POStoFIXED( 1 , 0 , 0) , { 1 , 4 , 7 , 2}} ,
	    {POStoFIXED(-1 , 0 , 0) , { 5 , 0 , 3 , 6}} ,
	    {POStoFIXED( 0 ,-1 , 0) , { 4 , 1 , 0 , 5}} ,
	    {POStoFIXED( 0 , 1 , 0) , { 2 , 7 , 6 , 3}} ,
	    {POStoFIXED( 0 , 0 , 1) , { 4 , 5 , 6 , 7}} ,
	} ;

attribute_tbl:
    .data.b	RevCheck	; \ɂ藠ɂȂʂ\邩ǂ
				  ̃tO
			SinglePlane  DualPlane ̂ꂩw肵܂B
    .data.b	SortMode	; \[eBO̊ɂʒu̎Zo@ƃIv
				  V@\̎gp錾܂B
			SortCen , SortMin , SortMax , SortBfr  ꂩ
	SortCen : w肳ꂽS_̂yʒu̕ς\[eBO̊Ɏgp܂
	SortMin : S_̓Ałyʒugp܂
	SortMax : S_̓Ał傫yʒugp܂
	SortBfr : Oɕ\ꂽ|Ŝyʒugp܂
		  Õ|S̏ɎOɕ\܂
			IvV͂ɉĎw肵܂
			UseTexture , UseLight , UseClip IvV͕w肷
			邱Ƃł܂B
	UseTexture : eNX`(ό`XvCg)gpꍇɎw肵܂B
	UseLight : xNgƖ@xNgƂ̓ςɂ|S̃J[
		ItZbg|Â\܂B
		UseTexture  ɂ͎gpł܂B
	UseClip : 傫ȃ|SgpꍇA\ʒuI[o[t[Đ
		\łȂ悤ȎɎgp܂B

    .data.w	TextNum		; eNX`gpꍇALN^̓o^
				  ƂĎgp܂B
    .data.w	DispMode	; |S̕\[hw肵܂B
				  wł\[hɂ͈ȉ̂̂܂
	MSBon : t[obt@ւ݂̏ɂčŏʃrbĝ݂Pɂ܂B
		(XvCgւ̃VhE͒ʏ킱gp܂)
	HSSon : nCXs[hVNL
	HSSoff: nCXs[hVN(default)
	WindowIn : w肵EBhE̓ɕ\܂B
	WindowOut : EBhE̊Oɕ\܂B
	NoWindow : (default)EBhEɉeꂸɕ\܂B

	MESHon : bVŕ\܂B
	MESHoff : (default)ʏ\܂B

	ECdis : eNX`gp鎞AGhR[h𖳌ɂ܂B
	ECenb : (default)eNX`gp鎞AGhR[hLɂ܂B

	SPdis : eNX`gp鎞AXy[X𖳌(pbgÕJ[
		\)ɂ܂B
		At[obt@ւ̏݃f[^ OOOOɂȂ
		ꍇɂ́A\܂̂ŁAvCIeB̒l𒲐
		OOOOɂȂȂ悤ɂĉB
	SPenb : (default)eNX`gpƂAXy[XLɂ܂B

	CL16Bnk : (default)eNX`̃J[[hPUF̃J[oN
		ɂ܂B
	CL16Look : eNX`̃J[[hPUF̃bNAbve[u
		ɂ܂B
	CL64Bnk : eNX`̃J[[hUSF̃J[oNɂ܂B
	CL128Bnk : eNX`̃J[[hPQWF̃J[oNɂ
		B
	CL256Bnk : eNX`̃J[[hQTUF̃J[oNɂ
		B
	CL32KRGB : eNX`̃J[[hRQOOOF̂qfaɂ܂

	CLrepl : (default)[hɂ܂B
	CLtrans : ŕ\܂B
	CLhalf : Pxŕ\܂B
	CLshadow : VhE\ɂ܂B
	CLgouraud : O[[VF[fBOw肵܂B

	\[h͊eO[v̂ꂩЂƂw肵܂B

    .data.w	Color		; \J[w肵܂B
	̉e󂯂ꍇA܂A\[h CLrepl ȊOw肷ꍇ
	͂qfa[hłȂ΂Ȃ܂B
	܂AeNX`gpꍇŁACL32KRGB[h̏ꍇɂ́Ał̎w
	͖܂B

    .data.w	GouraudTable	; O[[VF[fBOe[uw肵܂B
	CLgouraud w肵ꍇAO[[VF[fBOe[ũItZbg
	uw܂BItZbgʒu͂ruq`l(OQTbOOOO
	)OƂAWoCgƂɂPiޒlŎw肵܂B
	Ⴆ΁AOQTbPQOOOɃf[^ꍇ
	(QTbPQOOO|QTbOOOOO)^W  QSOO
						(lׂ͂ĂPUi)

    .data.w	Function	; XvCg\t@NVw肵܂B
	|SAeNX`A|ĈƂĕ\邩w肵܂B
	wɂ͈ȉ̂UЂƂIт܂B
	sprNoflip  : eNX`\܂B
	sprHflip   : eNX`ɔ]ĕ\܂B
	sprVflip   : eNX`cɔ]ĕ\܂B
	sprHVflip  : eNX`cAoɔ]ĕ\܂B
	sprPolygon : |SƂĕ\܂B
	sprPolyLine: |C(|S̗֊ŝ)\܂B

    bŃe[u쐬ꍇAATTR^錾ĂAATTRIBUTE
    }Ngp邱ƂŁAL̃f[^e[u쐬邱Ƃł܂B
  )
	static ATTR attr_CUBE[] = {
	    ATTRIBUTE(Single_Plane,SORT_MIN,No_Texture,CD_MediumGreen  ,
				No_Gouraud,Window_In,sprPolygon,UseLight) ,
	    ATTRIBUTE(Single_Plane,SORT_MIN,No_Texture,CD_MediumBlue   ,
				No_Gouraud,Window_In,sprPolygon,UseLight) ,
	    ATTRIBUTE(Single_Plane,SORT_MIN,No_Texture,CD_MediumMagenta,
				No_Gouraud,Window_In,sprPolygon,UseLight) ,
	    ATTRIBUTE(Single_Plane,SORT_MIN,No_Texture,CD_MediumWhite  ,
				No_Gouraud,Window_In,sprPolygon,UseLight) ,
	    ATTRIBUTE(Single_Plane,SORT_MIN,No_Texture,CD_MediumYellow ,
				No_Gouraud,Window_In,sprPolygon,UseLight) ,
	    ATTRIBUTE(Single_Plane,SORT_MIN,No_Texture,CD_MediumRed    ,
				No_Gouraud,Window_In,sprPolygon,UseLight)
	} ;

 XvCg\֐p̃Agr[gɂ

  slPutSprite() AslDispSprite() ŎgpAgr[ge[úAL̃|
  Sp̂̂ƂقړłA擪̂Q̃f[^ȂȂĂ܂B
    bł̃e[u쐬ꍇASPR_ATTR^錾ĂA
  SPR_ATTRIBUTE}Ngp邱Ƃł܂B
  )
	SPR_ATTR attr_AM2Logo = {
	    SPR_ATTRIBUTE(PN_AM2_Logo,CL_AM2_Logo,No_Gouraud,Window_In|ECdis,
		sprNoflip|_ZmCB)
	} ;

	_ZmCB ̓|WVXvCĝǂ̈ʒuww肷̂ŁA
	ȉ̂X`Ă܂B

	_ZmLT	_ZmCT	_ZmRT
	   +-------+-------+
	   |       |       |
     _ZmLC +----_ZmCC------+ _ZmRC
	   |       |       |
	   +-------+-------+
	_ZmLB	_ZmCB	_ZmRB

 XvCg\Tv

#define		CGtop			0x10000
#define		TEXTBL(hs,vs,cga)	{hs , vs , (cga)>>3 , ((hs)&0x1f8)<<5|(vs)}
#define		AdjCG(cga,hs,vs,col)	((cga + (((hs)*(vs)*4)>>(col)) + 0x1f) & 0x7ffe0)
#define		PICTBL(txno,cmod,cga)	{txno , cmod , cga}
#define		CL_Triangle		0x00

    static const Uint16 triangle[] = {
	0x0000,0x0001,0x1000,0x0000,	/* XvCg̃LN^f[^ */
	0x0000,0x0012,0x2100,0x0000,
	0x0000,0x0123,0x3210,0x0000,
	0x0000,0x1234,0x4321,0x0000,
	0x0001,0x2344,0x4432,0x1000,
	0x0012,0x3333,0x3333,0x2100,
	0x0122,0x2222,0x2222,0x2210,
	0x1111,0x1111,0x1111,0x1111
    } ;

    enum patn{
	PN_Triangle ,			/* XvCgp^[io[ */

	Max_Texture ,			/* p^[ */
	Max_Picture = Max_Texture	/* LN^ */
    } ;

    enum cga{				/* LN^AhX */
	CG_Triangle = CGtop ,
	CG_Next = AdjCG(CG_Triangle,16,8,COL_16)
    } ;

    TEXTURE form_tbl[]={		/* p^[TCYf[^ */
        TEXTBL(16,8,CG_Triangle)
    } ;

    PICTURE pic_tbl[]={			/* LN^`e[u */
        PICTBL(PN_Triangle,COL_16,triangle)
    } ;

    static const Sint16 Triangle_Color[] = {	/* J[f[^ */
                        RGB(0,0,31) , RGB(0,0,29) , RGB(0,0,27) ,
          RGB(0,0,25) , RGB(0,0,23) , RGB(0,0,21) , RGB(0,0,19) ,
          RGB(0,0,17) , RGB(0,0,15) , RGB(0,0,13) , RGB(0,0,11) ,
          RGB(0,0,9)  , RGB(0,0,7)  , RGB(0,0,5)  , RGB(0,0,3)
    } ;

    typedef struct{			/* J[`p\ */
	Sint16	    *src ;
	void	    *dst ;
	Sint16	     size ;
    } COLMAP ;

    static const COLMAP ctrns_list[] = {	/* J[`e[u */
        {Triangle_Color,(void*)(VDP2_COLRAM+(CL_Triangle+1)*2),sizeof(Triangle_Color)}
    } ;

    extern TEXTURE *FormTbl ;

/*						*/
/*  LN^f[^]			*/
/*						*/

void SetTexture(PICTURE *pcptr , Uint32 NbPicture){
    TEXTURE *txptr ;

    for(; NbPicture-- > 0 ; pcptr++){
        txptr = FormTbl + pcptr->texno ;
        slDMACopy(pcptr->pcsrc , (void *)(SpriteVRAM + ((txptr->CGadr) << 3)) , (txptr->Hsize * txptr->Vsize * 4) >> (pcptr->cmode)) ;
    }
}

/*						*/
/*  J[f[^]				*/
/*						*/

void SetColor(){
    COLMAP      *cmptr ;
    Sint16       cnt ;

    slTVOff() ;
    cmptr= ctrns_list ;
    for(cnt = sizeof(ctrns_list) / sizeof(COLMAP) ; cnt-- > 0 ; cmptr++){
        slDMACopy(cmptr->src , cmptr->dst , cmptr->size) ;
    }
    slTVOn() ;
}

/*  TvLN^\ʒu */
    FIXED  tpos[] = {toFIXED(10.0) , toFIXED(20.0) , toFIXED(200.0) , toFIXED(4.0)} ;
/*			|		|		|		 |__ \XP[			*/
/*			wʒu		xʒu		yʒu		 |__ ({ Ȃ toFIXED(ORIGINAL) ŵ)	*/

/*  TvLN^f[^ */
    SPR_ATTR tattr = SPR_ATTRIBUTE(PN_Triangle,CL_Triangle,No_Gouraud,CL16Bnk,sprNoflip|_ZmCC) ;
/*					|	    |		|	|	  |	  |__ ]Sʒu */
/*					|	    |		|	|	  |__ LN^]͂Ȃ */
/*					|	    |		|	|__ PUFJ[oN[h	   */
/*					|	    |		|___ O[[VF[fBO͎gpȂ	   */
/*				p^[io[  J[oNio[					   */

main(){
    ANGLE	ang = DEGtoANG(0.0) ;

    *(Uint32 *)(0x06002500) = (Uint32)(0x060007f0) ;
/*  NbN`FW̓TEhp̂UWjXCb`f[^ǂ݁AɃZbgꂽ
    AhXɃf[^pӂ炵̂A܂ĂȂ悤Ȃ̂ŁAƂ肠
    ĂȂf[^OeeeêAhXĂ */

    slInitSystem(TV_320x224 , form_tbl , 1) ;	/* VXe */
    SetTexture(pic_tbl , Max_Picture) ;		/* LN^f[^̃Zbg */
    SetColor() ;				/* J[f[^̃Zbg */
    while(-1){
	slDispSprite(tpos , &tattr , ang) ;	/* XvCg̓o^ */
	ang += DEGtoANG(3.0) ;
	slSynch() ;				/* ʕ\ւ̓Ƃ̃XvCgo */
    }
}
