How to manually initialize a bitmap

alfkil wrote:
I want to be able to render directly to a texture in video memory. How can I do that? I'm thinking, that I somehow need to create a bitmap structure for that texture, that I can then pass on to the minigl CreateContext call. But I can find no information on how to set up the planes[] pointers in truecolor mode.

alfkil wrote:
@broadblues

I really mean "render to texture", yes.

The problem I am facing is this: QPixmap is a memory representation of an image. This image can be rendered to the screen in various ways: It can be tiled, rotated, streched and perspectiviced (for instance if you attach it to a QBrush and use this brush for drawing). For all this to be possible, it needs to be represented as an opengl _texture_. Simple blits will not do, so I cannot just use a standard bitmap.

You can do bitmap rotation, scaling and 2D warping using CompositeTags() with vertex arrays.

WARNING: There is no software fallback for vertex-array based compositing.

TSK wrote:
@Hans
Quote:

WARNING: There is no software fallback for vertex-array based compositing.

Do this mean full 3D support is required or hardware compositing only ? I mean, do this vertex stuff work with current public RadeonHD drivers ?

@Hans + everybody
Btw. Do anybody know how to use compositing engine to do blue/green screen stuff ?

+ Now, if somebody could teach me how to manipulate alpha channel stuff ? For example, half of a window area being dark and the other half being bright.

typedef struct Vertex_s {
   float x, y;
   float s, t, w;
} Vertex_t;

blue/green screen stuff

Chroma-keying is a different operation

You could start by creating an ARGB bitmap, and then use the fill rect operation to render a rectangle

Quote from Autodocs for SetRPAttrs() and RPTAG_APenColor: "The alpha part is currently ignored and should be set to 0xFF".

So it looks like no chance at the moment.

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.