shift pattern

[AGS]

Hello,

I am filling a rectangle with a pattern. The pattern starts always in the left top corner of my rectangular block. Now, when I move the block, the pattern moves with it. What I would like to get is, that the pattern stays fixed, but is only visible within my block. I did this with this pattern and it worked:

vscrollpattern
        dc.w    %1010101010101010
        dc.w    %0101010101010101

vscrollpattern_shifted
        dc.w    %0101010101010101
        dc.w    %1010101010101010

When the coordinate is odd, then i simply use the shifted pattern.

But now I would like to do the same with a pattern that does NOT repeat after two pixels:

.ghostpattern    dc.w    %1000100010001000
        dc.w    %0010001000100010

I can't work with even/odd here. But how can I get the same effect of a fixed pattern? I would use differently shifted patterns for this purpose (as above with the 2 pixel pattern, but how to decide when which of those should be used?

Thanks in advance,
ags

[thomas]

Divide the x coordinate of the left edge of your block by the width of the pattern and use the remainder as the number of bits you have to shift the pattern horizontally.

Do the same with the top edge of your block and the height of the pattern to shift the pattern vertically.

[AGS]

That's a good idea. I am trying to calc and apply the x-shift for a pattern that is 16 pixels wide and 2 pixels high:

		lea	.ghostpattern(pc),a0

.y		move.w	oxNB_top(a3),d0
		btst	#0,d0
		beq	.x
		addq.l	#2,a0

.x		movem.w	(a0),d0/d1	; read pattern

		move.w	oxNB_left(a3),d2
		move.w	d2,d3
		lsr.w	#4,d3
		lsl.w	#4,d3
		sub.w	d3,d2
		rol.w	d2,d0		; shift pattern horizontally
		rol.w	d2,d1

		movem.w	d0/d1,-(a7)	; put pattern on stack

		move.l	a7,rp_AreaPtrn(a2)

...
...

.ghostpattern	dc.w	%1000100010001000
		dc.w	%0010001000100010
		dc.w	%1000100010001000

For y I simply look even/odd and step one line further in the pattern data (higher than needed by one line).

For x I think I divide by 16, multiply by 16, then substract the result from the left coordiante to get the remainder and then shift the pattern by that.

For y it works, but for x not. What now?

ags


EDIT: I found it! Must be ROR. not ROL. lol

[thomas]

What about this to get the remainder for x:

	moveq	#15,d2
	and.w	oxNB_left(a3),d2

[AGS]

LOL, it works!

[Don_Adan]

Writing Amiga GUI slowest than MUI has no big sense, especially in ASM.
You can try to use next code, if you want:

		lea	.ghostpattern(pc),a0

.y		move.w	oxNB_top(a3),d0
		btst	#0,d0
		beq	.x
		addq.l	#2,a0

.x		move.l	(a0),d0	; read pattern
                moveq     #15,D1
		and.w	oxNB_left(a3),d1
		ror.w	        d1,d0		; shift pattern horizontally
		move.w	d0,-(a7)	; put pattern on stack
                swap        d0
		ror.w	        d1,d0		; shift pattern horizontally
		move.w	d0,-(a7)	; put pattern on stack


		move.l	a7,rp_AreaPtrn(a2)

...
...

.ghostpattern	dc.w	%1000100010001000
		dc.w	%0010001000100010
		dc.w	%1000100010001000

[Thorham]

Why not simply put the pattern data into rp_AreaPtrn(a2) directly?

.x
    move.l  (a0),d0
    moveq   #15,d1
    and.w   oxNB_left(a3),d1
    rol.w   d1,d0
    swap    d0
    rol.w   d1,d0
    move.l  d0,rp_AreaPtrn(a2)

[thomas]

Because rp_AreaPtrn is an address (a pointer), not a value.

[Thorham]

Originally Posted by thomas

Because rp_AreaPtrn is an address (a pointer), not a value.

That's quite obvious, of course. The question is why you should point to the pattern when you can store it directly? If the pointer always points to two words (or a long word), then you can store it directly. This also avoids putting the stack pointer into this member. It's about avoiding indirection if you don't have to go to lengths to avoid it, and this seems to be such a case.

[Thorham]

To AGS:

You can also do it like this (uses the stack as in your code):

.y
    moveq   #1,d0
    and.w   oxNB_top(a3),d0
    add.w   d0,d0
    lea     .ghostpattern(pc,d0.w),a0

    move.l  (a0),d0
    moveq   #15,d1
    and.w   oxNB_left(a3),d1
    rol.w   d1,d0
    swap    d0
    rol.w   d1,d0
    move.l  d0,-(sp)
    move.l  sp,rp_AreaPtrn(a2)

    ...
    ...
    ...

.ghostpattern
    dc.w    %1000100010001000
    dc.w    %0010001000100010
    dc.w    %1000100010001000

[AGS]

Thanks Thorham, now I use your code. I think it is faster but did not count it. Actually this piece of code is only called when a button is drawn in ghost-state. This is seldom. There are core routines in my lib that eat up most of the valuable time. Optimizing these would be fine, but I don't think it is possible. Please look into the GUI thread.

[Thorham]

Originally Posted by AGS

Actually this piece of code is only called when a button is drawn in ghost-state.

Is the code called only once per button?

[AGS]

Yes.

[Thorham]

Good

[thomas]

Originally Posted by Thorham

That's quite obvious, of course. The question is why you should point to the pattern when you can store it directly? If the pointer always points to two words (or a long word), then you can store it directly. This also avoids putting the stack pointer into this member. It's about avoiding indirection if you don't have to go to lengths to avoid it, and this seems to be such a case.

Erm, the RastPort is part of the API. You cannot change the API of AmigaOS (graphics.library).

Furthermore the pattern can have any height, as long as it is a power of 2.

[Thorham]

Originally Posted by thomas

Erm, the RastPort is part of the API. You cannot change the API of AmigaOS (graphics.library).

Thought the member is part of the program itself

[AGS]

Thorham, just to let you know, in your source it must be ROR, not ROL.