World: r3wp

Maxim, no problem, I have not much time either now so feel free to 
clarify any time later.

I was just wondering what you are looking for to satisfy your needs.

And of course, you cannot request functionality of big complex 3D 
systems which are usually fat high-level layers over  low level graphics 
libraries.

You should think about the DRAW at the level of graphic library api, 
not application layer.

So I more awaited comparison with OpenGL, DIrectX, Cairo, Qt , Java2d 
 and so on. Anyway, I'm curious about your  examples....

Also I don't understand what is so wrong on using dialect as an interface 
when Rebol should be the case where working with blocks, dialects 
etc. should be a plus.

For example If you prefer interface based on function calls over 
dialect the I'd like to know what benefits you see in that approach 
etc.

Gabriele, i don't think so. (regarding the definition on wikipedia).
Actually, I used a technic very similar to what's done in R2.

In R2 the event engine throw tons of time events aswell. But the 
filtering (regarding which face as a rate property) is automatic 
(more or less).

Steeve, but were you succesfull to use this technique in real world 
case? I tried to use it for the DRAW demo but it doesn't work well.

Try: do http://www.rebol.cz/~cyphre/scripts/r3/tests/draw-shapes-2.r


-try to move mouse over the window..you should see quick 'MOVE'  
events  eing logged in the console

-if you select any object using the mouse the loop is starting to 
do something usefull and from that time I could get only about 3 
MOVE events per second which is very slow. To me it looks like the 
event port blocks during execution of the code inside the WAKE handler.

But if I use the same code inside FOREVER+WAIT cycle the events are 
comming much more frequently.

The problem with FOREVER+WAIT in R3 though is it eats up 100% of 
CPU time(as opposed in R2) and I don't know why. Probably a question 
for Carl.

if you slow done your frame rate at 10 or 15 fps and increase the 
wait duration at 0.04, it might not hang up the cpu but il will be 
too slow.

Meaning only one thing to my mind, Rebol' s drawing engine is too 
slow when drawings are huge (slow by design)

*slow down

Henrik, in your last try, if you skip some time events  then the 
animation slow down but it's eating only 50% of my cpu (a small celeron).

tick: 0
...
handler: func [event] [
	switch event/type [
		time [
			++ tick
			if all [picked-obj tick > 30] [ 
				tick: 0
...

Rebol is slow for such animations

Moreover, you're using the graphic engine quite intensivly.
For each refresh:
-  2 calls to the draw the function + 2 shows


Maybe only one show of a composed gob (without the need to call draw 
seperatly) would increase the perfs.

Nope, the 2 shows are necessary and in fact optimizes the whole thing 
because you don't need to refresh whle screen everytime...better 
two smaller shows than one fullscreen redraw in this case.


The problem I was refering is not about performance..it is about 
blocking when executing longer code from AWAKE handler. I think this 
method is not usable.

When I run it using the forever+wait loop it works without problem 
at constant 28 fps here even if I wait for 10 miliseconds during 
each refresh. I only don't understand why 10ms is not enough to let 
cpu service the rest of system. Imo in R3 the CPU is not knowing 
about the wait/idle state from some reeason.

Well, i didn't say to refresh the whole screen but only one composed 
gob (and to discard the callings to draw).

but it's true that time events will not be faster than a forever 
loop.
It was already true with R2

The demo is about  thechnique where you can manage DRAW only objects 
in one gob so if I split the content to multiple gobs and compose 
them  it would ruin the whole concept.

As I said the problem is not in the demo itselt...it is in the timing/loop 
code.

You can  easily to see it if you put some code(doesnt have to be 
related to draw or even graphics) in your small example you posted 
previously. You will see the same slowndown which means: don't put 
time consuming code into the AWAKE handler. But where to put it if 
you generate time events in that place? :)

But are you sure your technic (of calling the draw function and then 
to show the image-gobs )is faster than letting the draw engine doing 
the whole job with one show?

definitely

ok i trust you ;-)

Note that the two draw calls also uses clipping so in fact the draw 
engine is rendering only the really needed parts.

so the clipping is done at rendering level and also at blitting level. 
While if you do a show on one big gob with draw you are rendering/bliting 
everything.

ofcourse if you want to do 100 smaller places on the screen then 
it is usually better to refresh whole screen ;)

Btw i think the throwing of time events can be optimized by modifying, 
the system handler:

>> ? :system/ports/system/awake
make function! [[
    sport "System port (State block holds events)"
    ports "Port list (Copy of block passed to WAIT)"
    /local event port waked
][
    waked: sport/data
    loop 8 [
        if not event: take sport/state [break]
        port: event/port
        if wake-up port event [
            if not find waked port [append waked port]
        ]
    ]
    if not block? ports [return none]
    forall ports [
        if find waked first ports [return true]
    ]
    false

instead of pushing back, 8 times, the time event (the worst case), 
we could push it only one time

well, try it..need to leave now. I still think the tie event generation 
is not usable until you move the receiving place from AWAKE handler 
to other place (as it was in R2 - face/feel/engage)

(Using time events)

Cyphre, By reducing the number of objets to draw (10 objects) I have 
a really smouth animation taking less than 2% of UC when an object 
is rotating, and growing to 20% maximum when the object is actually 
moving.
Meaning your clipping technic has a  low effect on perfs.

and with 50 objects, i have 30% to 50% CPU usage.
Time events are not so bad.

http://sites.google.com/site/rebolish/test-1/draw-shapes-22.r

Steeve,

clipping: I disagree here,you cannot compare the clipping effect 
by increasing/reducing number of renedered objects. The only valid 
test is to to compare rendering of same number of objects with and 
without the clipping being enabled. Note that the perfomance slowdown 
you are reporting when adding more objects doesn't have to be related 
to clipping.


regarding your new version..sorry, I'm still not convinced. It looks 
to me you just replicated the same busy loop as when I use FOREVER+WAIT 
technique. You are simulating kind of 'wait' using the tick skipping 
but the result is same when looking at the CPU usage.

I still wonder why we need to 'wait' too much in R3 unless CPU load 
starts dropping down.

When I have time,I'll try to create some test script which can be 
indentically used in R2 and R3 to see if there is really any difference.

Steeve: a busy loop means that the CPU is busy looping. That is what 
happens in your example. There is no "sleep" time between time events. 
That is not true with actual time events, which fire at a defined 
interval, and allow the CPU to sleep between them.

replacing a wait with a counter... oh well... :)

Steeve - your script reports some error here:


>> do http://sites.google.com/site/rebolish/test-1/draw-shapes-22.r
Script: "Untitled" Version: none Date: none
** Script error: Moved has no value
** Where: catch either either applier do
** Near: catch/quit either var [[do/next data var]] [data]

Gabriele, you can't be more wrong. There is obviously sleep times 
in my example.

I reported that the CPU usage is variyng a lot depending what time 
events are triggering. There's no need to argue again facts. Obviously, 
less CPU usage means the CPU is sleeping somewhere.

Henrik, same argument, It's not a busy loop. Have you Guys tested 
or not ?

Sorry, Cyphre, not Henrik

Pekr, you can't use Rebol to "do " the script at this remote location 
 , you must download it at first.
(no redirection supported by http in R3)

Steeve, ah, I see, you are basically processing your fake time events 
whenever other events happen (eg. mouse moves). But if that's the 
case, then there is absolutely no point in using those fake time 
events. Also, there is no guarantee you are going to get events...

It is still a very silly way to do what Cyphre is doing, more consistently, 
by just using a FOREVER loop with WAIT.

Dropping by. Looking back.

It looks like this discussion evolved a lot.  Let me know if there 
is a question I can answer about it.

And, it's possible there's a bug. See last line of:
>> dt [loop 10 [wait 0.1]]
== 0:00:01.000138
>> dt [loop 100 [wait 0.01]]
== 0:00:01.000423
>> dt [loop 1000 [wait 0.001]]
== 0:00:01.003355
>> dt [loop 10000 [wait 0.0001]]
== 0:00:00.01414  <-- wrong

not yet reported to curecode.

This might be related to the timing resolution change we made a few 
versions ago.

my output is different (VirtualBox WinXP):

>> dt [loop 10 [wait 0.1]]
== 0:00:01.00047

>> dt [loop 10 [wait 0.01]]
== 0:00:00.100501

>> dt [loop 10 [wait 0.001]]
== 0:00:00.010723

>> dt [loop 10 [wait 0.0001]]
== 0:00:00.000234

argh, forgot to loop more than 10 times. forget it.

It still goes wrong in that last case.

Anyway... on above CPU issue... the metric is this: R3 should be 
as good or better than R2 in this.

In other words, there's no reason it should't be.  Also, we know 
the code has a few problems on non-windows boxes.

BTW, the relevant code is host-device.c, line 406 and below.

*/	REBINT OS_Wait(REBCNT millisec, REBCNT res)
/*
**		Check if devices need attention, and if not, then wait.
**		The wait can be interrupted by a GUI event, otherwise
**		the timeout will wake it.

Specifically:
	// Nothing, so wait for period of time
	delta = (REBCNT)OS_Delta_Time(base, 0)/1000 + res;
	if (delta >= millisec) return 0;
	millisec -= delta;  // account for time lost above
	req.length = millisec;

Robert and I are discussing field persistence, i.e. tieing fields 
directly to database tables in a layout. Going to be a bit about 
our conclusions in the R3 GUI specs soon.

The question is: How to get from GUI to a DB and back without cluttering 
the VID code, or having to code to much. The idea is to collect the 
GUI elements belonging to one record and than auto-create tables 
and columns. So, people can concentrate on the app code and get the 
75% always necessary database code for free.

If you have any ideas, hints let us know.


We have a first prototype running, but we want to make it more elegant.

Well, if you show us something it will be easier to propose ideas.
I'm working on my own GUI aswell currently :)