ssolie wrote:
That bug is fixed in 4.1 Update 4 for all platforms so there shouldn't be any problems there.

djrikki wrote:
*Everyone replies in Unison*


"Two more weeks...!"

i take it there may be a version running at amiwest this weekend?

Btw, just for learning purposes: those bugs was because of cairo, or just because of code-porting of firefox ?

Btw, current public version use HW-accelerated cairo and compositing or not ? I mean did i understand right, that current public beta are use HW-accelerated cairo, but the new one, will not use it , and because of it will be a bit slower in rendering ?

Do you think it could be possible to implement a bit more native GUI already in this first Alpha version ? (expecially menus)

Also how about the real speed ?
Ok you say a bit slow, yep currently i think it's quite normal for that HTML5 videos but how about "normal" navigation ?

Once released can be already usable on a slow hardware (like Sam440 for example) ?

It looks like w does nothing. No matter what value I put there nothing changes and the picture looks twisted when rotating it around x or y axis.

* VERTEX ARRAY MODE
*
* Instead of using a rectangle, the Composite call can also use
* triangles defined by an array of vertices. When in vertex array
* mode, the tag items COMPTAG_SrcX, COMPTAG_SrcY, COMPTAG_SrcWidth,
* COMPTAG_SrcHeight, COMPTAG_ScaleX, COMPTAG_ScaleY,
* COMPTAG_OffsetX and COMPTAG_OffsetY are ignored. Instead of
* rendering a single quad, the compositing engine will render a
* set of (disjoint) triangles using the composition source as
* a "texture".
*
* A vertex array is a set of points on the 2D plane. Each vertex
* consists of at least two floating point values defining the x
* and y coordinates of the vertex on the destination operator,
* relative to the top left corner of the bitmap (not the
* destination rectangle!). Furthermore, each vertex can have
* three or six more floating point value attributes, both of which
* are sets of texture coordinates.
*
* The first set of extra coordinates, if present, address the
* source operator bitmap itself. The second set, if present,
* are used to address the alpha mask. Each set consists of three
* floating point values. The first two values, named s and t
* respectively, define the X and Y coordinates on the source
* operator bitmap that this vertex maps to. The third, called w,
* is a homogenous space coordinate of the texture. Usually, this
* will be 1.0f, but it is possible to use different homogenous
* coordinates per vertex to achieve a perspective corrected 3D
* texture map
*
* The tag COMPTAG_VertexFormat is used to describe the format of
* each individual vertex. If ommited, the default value is for
* a vertex to only have x and y coordinates. Otherwise, the
* tag's value must be a compination of the two values
* COMPVF_STW0_Present and COMPVF_STW1_Present. These two values
* are bit masks and can be combined in any form. Each bit adds
* three floating point values to the vertex' required size. When
* both are specified, each vertex has a size of 8 floating point
* values.
*
* Vertex arrays must be specified compact, i.e. to get from one
* vertex in the array to the next, the compositing engine adds
* the size of the vertex, in bytes. Typically, your application
* would define a vertex "structure" like this:
*
* typedef struct {
* float x,y;
* float s,t,w;
* } myVertex_t;
*
* #define MYVERTEX_Format COMPVF_STW0_Present
*
* A vertex array could then be defined as
*
* myVertex_t vertices[20];
*
* The tag COMPTAG_VertexArray is used to enter triangle mode by
* providing a packed vertex array as described above. The
* size of the vertex array is undefined.
*
* A vertex array does not, however, define triangles. It only
* defines vertices. To start drawing triangles, these vertices
* must be grouped into triplets that define a triangle. There are
* two possible ways to do that, either implicitly, or explicitly.
*
* The normal mode of operation is to assume implicit grouping of
* vertices into triangles. Each three consequtive vertices,
* starting at vertex index zero, is assumed to be one triangle,
* i.e. the first triangle consists of indices 0, 1 and 2, the
* second one consists of indices 3, 4 and 5, and so on. The
* number of triangles to draw is specified via
* COMPTAG_NumTriangles, and the vertex array must have at least
* three times this number of vertices.
*
* The second mode of operation is explicit index mode. In index
* mode, the triangles are not defined by the order of vertices
* in the index array. Instead, the caller can pass an explicit
* array of indices for each triangle. As in the implicit mode,
* the tag COMPTAG_NumTriangles determines how many triangles are
* drawn, but the size of the vertex array is unaffected by this
* value, since each vertex may be used zero or more times through
* specifying its index. To pass in the indices of the desired
* triangles, the tag COMPTAG_IndexArray can be used. Indices are
* passed in as an array of 16 bit unsigned integers. If we denote
* the index array as I and the vertex array as V, then triangles
* are defined as
*
* V[I[0]], V[I[1]], V[I[2]]
* V[I[3]], V[I[4]], V[I[5]]
* and so on.
*
* The number of vertices in the array must be at least as many as
* the highest index used in the index array. No consistency check
* is done whatsoever for speed reasons, so an application has to
* take care the input to this function is valid. Failure to do so
* will have an undefined result, with "undefined" ranging from
* "nothing at all" to "total system lockup".
*
* IMPORTANT: As of AmigaOS 4.1 Update 3, triangle mode only works
* with hardware accelerated rendering. There is currently no
* software fallback.

I want to know the origin because if all ports for AOS4 are new that mean some time to be made and if based on AROS, less time to be made, thats all...

As hans answered recently MESA and GALLIUM, for me the port for AOS4 is 99% based from the AROS port (of course IMHO)....

OpenGL (???): just mean unknown origin and one, two or tree ??? is allways the same question

But maybe nice to speculate about what it will mean for OS4 in the future...

And if aros code even can help (As Hans say), i think it will be pretty strange to not say about AROS at all, you don't think so ?

1- MESA and GALLIUM from AROS.
or
2- OPENGL (new port) and GALLIUM from AROS.