mirror of
https://github.com/brl/mutter.git
synced 2024-12-27 21:32:14 +00:00
a81435ab5f
This basically reverts commit 54735dec, which tried to avoid the
GLib-defined types in favor the standard C ones. One exception to this
is the bool type, for which the commit introduces a new type CoglBool.
Let's just get rid of this type in favor of having consistency with the
GLib types. Note by the way that neither CoglBool nor gboolean (which
has a size of `int`) are completely compatible with bool (size `char`).
https://gitlab.gnome.org/GNOME/mutter/merge_requests/321
270 lines
7.3 KiB
C
270 lines
7.3 KiB
C
/*
|
|
* Cogl
|
|
*
|
|
* A Low Level GPU Graphics and Utilities API
|
|
*
|
|
* Copyright (C) 2010 Intel Corporation.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person
|
|
* obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use, copy,
|
|
* modify, merge, publish, distribute, sublicense, and/or sell copies
|
|
* of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*
|
|
*
|
|
*
|
|
* Authors:
|
|
* Robert Bragg <robert@linux.intel.com>
|
|
* Neil Roberts <neil@linux.intel.com>
|
|
*/
|
|
|
|
#include "cogl-config.h"
|
|
|
|
#include "cogl-util.h"
|
|
#include "cogl-object-private.h"
|
|
#include "cogl-context-private.h"
|
|
#include "cogl-indices.h"
|
|
#include "cogl-indices-private.h"
|
|
#include "cogl-index-buffer.h"
|
|
#include "cogl-gtype-private.h"
|
|
|
|
#include <stdarg.h>
|
|
|
|
static void _cogl_indices_free (CoglIndices *indices);
|
|
|
|
COGL_OBJECT_DEFINE (Indices, indices);
|
|
COGL_GTYPE_DEFINE_CLASS (Indices, indices);
|
|
|
|
static size_t
|
|
sizeof_indices_type (CoglIndicesType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case COGL_INDICES_TYPE_UNSIGNED_BYTE:
|
|
return 1;
|
|
case COGL_INDICES_TYPE_UNSIGNED_SHORT:
|
|
return 2;
|
|
case COGL_INDICES_TYPE_UNSIGNED_INT:
|
|
return 4;
|
|
}
|
|
g_return_val_if_reached (0);
|
|
}
|
|
|
|
CoglIndices *
|
|
cogl_indices_new_for_buffer (CoglIndicesType type,
|
|
CoglIndexBuffer *buffer,
|
|
size_t offset)
|
|
{
|
|
CoglIndices *indices = g_slice_new (CoglIndices);
|
|
|
|
indices->buffer = cogl_object_ref (buffer);
|
|
indices->offset = offset;
|
|
|
|
indices->type = type;
|
|
|
|
indices->immutable_ref = 0;
|
|
|
|
return _cogl_indices_object_new (indices);
|
|
}
|
|
|
|
CoglIndices *
|
|
cogl_indices_new (CoglContext *context,
|
|
CoglIndicesType type,
|
|
const void *indices_data,
|
|
int n_indices)
|
|
{
|
|
size_t buffer_bytes = sizeof_indices_type (type) * n_indices;
|
|
CoglIndexBuffer *index_buffer = cogl_index_buffer_new (context, buffer_bytes);
|
|
CoglBuffer *buffer = COGL_BUFFER (index_buffer);
|
|
CoglIndices *indices;
|
|
CoglError *ignore_error = NULL;
|
|
|
|
_cogl_buffer_set_data (buffer,
|
|
0,
|
|
indices_data,
|
|
buffer_bytes,
|
|
&ignore_error);
|
|
if (ignore_error)
|
|
{
|
|
cogl_error_free (ignore_error);
|
|
cogl_object_unref (index_buffer);
|
|
return NULL;
|
|
}
|
|
|
|
indices = cogl_indices_new_for_buffer (type, index_buffer, 0);
|
|
cogl_object_unref (index_buffer);
|
|
|
|
return indices;
|
|
}
|
|
|
|
CoglIndexBuffer *
|
|
cogl_indices_get_buffer (CoglIndices *indices)
|
|
{
|
|
return indices->buffer;
|
|
}
|
|
|
|
CoglIndicesType
|
|
cogl_indices_get_type (CoglIndices *indices)
|
|
{
|
|
_COGL_RETURN_VAL_IF_FAIL (cogl_is_indices (indices),
|
|
COGL_INDICES_TYPE_UNSIGNED_BYTE);
|
|
return indices->type;
|
|
}
|
|
|
|
size_t
|
|
cogl_indices_get_offset (CoglIndices *indices)
|
|
{
|
|
_COGL_RETURN_VAL_IF_FAIL (cogl_is_indices (indices), 0);
|
|
|
|
return indices->offset;
|
|
}
|
|
|
|
static void
|
|
warn_about_midscene_changes (void)
|
|
{
|
|
static gboolean seen = FALSE;
|
|
if (!seen)
|
|
{
|
|
g_warning ("Mid-scene modification of indices has "
|
|
"undefined results\n");
|
|
seen = TRUE;
|
|
}
|
|
}
|
|
|
|
void
|
|
cogl_indices_set_offset (CoglIndices *indices,
|
|
size_t offset)
|
|
{
|
|
_COGL_RETURN_IF_FAIL (cogl_is_indices (indices));
|
|
|
|
if (G_UNLIKELY (indices->immutable_ref))
|
|
warn_about_midscene_changes ();
|
|
|
|
indices->offset = offset;
|
|
}
|
|
|
|
static void
|
|
_cogl_indices_free (CoglIndices *indices)
|
|
{
|
|
cogl_object_unref (indices->buffer);
|
|
g_slice_free (CoglIndices, indices);
|
|
}
|
|
|
|
CoglIndices *
|
|
_cogl_indices_immutable_ref (CoglIndices *indices)
|
|
{
|
|
_COGL_RETURN_VAL_IF_FAIL (cogl_is_indices (indices), NULL);
|
|
|
|
indices->immutable_ref++;
|
|
_cogl_buffer_immutable_ref (COGL_BUFFER (indices->buffer));
|
|
return indices;
|
|
}
|
|
|
|
void
|
|
_cogl_indices_immutable_unref (CoglIndices *indices)
|
|
{
|
|
_COGL_RETURN_IF_FAIL (cogl_is_indices (indices));
|
|
_COGL_RETURN_IF_FAIL (indices->immutable_ref > 0);
|
|
|
|
indices->immutable_ref--;
|
|
_cogl_buffer_immutable_unref (COGL_BUFFER (indices->buffer));
|
|
}
|
|
|
|
CoglIndices *
|
|
cogl_get_rectangle_indices (CoglContext *ctx, int n_rectangles)
|
|
{
|
|
int n_indices = n_rectangles * 6;
|
|
|
|
/* Check if the largest index required will fit in a byte array... */
|
|
if (n_indices <= 256 / 4 * 6)
|
|
{
|
|
/* Generate the byte array if we haven't already */
|
|
if (ctx->rectangle_byte_indices == NULL)
|
|
{
|
|
uint8_t *byte_array = g_malloc (256 / 4 * 6 * sizeof (uint8_t));
|
|
uint8_t *p = byte_array;
|
|
int i, vert_num = 0;
|
|
|
|
for (i = 0; i < 256 / 4; i++)
|
|
{
|
|
*(p++) = vert_num + 0;
|
|
*(p++) = vert_num + 1;
|
|
*(p++) = vert_num + 2;
|
|
*(p++) = vert_num + 0;
|
|
*(p++) = vert_num + 2;
|
|
*(p++) = vert_num + 3;
|
|
vert_num += 4;
|
|
}
|
|
|
|
ctx->rectangle_byte_indices
|
|
= cogl_indices_new (ctx,
|
|
COGL_INDICES_TYPE_UNSIGNED_BYTE,
|
|
byte_array,
|
|
256 / 4 * 6);
|
|
|
|
g_free (byte_array);
|
|
}
|
|
|
|
return ctx->rectangle_byte_indices;
|
|
}
|
|
else
|
|
{
|
|
if (ctx->rectangle_short_indices_len < n_indices)
|
|
{
|
|
uint16_t *short_array;
|
|
uint16_t *p;
|
|
int i, vert_num = 0;
|
|
|
|
if (ctx->rectangle_short_indices != NULL)
|
|
cogl_object_unref (ctx->rectangle_short_indices);
|
|
/* Pick a power of two >= MAX (512, n_indices) */
|
|
if (ctx->rectangle_short_indices_len == 0)
|
|
ctx->rectangle_short_indices_len = 512;
|
|
while (ctx->rectangle_short_indices_len < n_indices)
|
|
ctx->rectangle_short_indices_len *= 2;
|
|
|
|
/* Over-allocate to generate a whole number of quads */
|
|
p = short_array = g_malloc ((ctx->rectangle_short_indices_len
|
|
+ 5) / 6 * 6
|
|
* sizeof (uint16_t));
|
|
|
|
/* Fill in the complete quads */
|
|
for (i = 0; i < ctx->rectangle_short_indices_len; i += 6)
|
|
{
|
|
*(p++) = vert_num + 0;
|
|
*(p++) = vert_num + 1;
|
|
*(p++) = vert_num + 2;
|
|
*(p++) = vert_num + 0;
|
|
*(p++) = vert_num + 2;
|
|
*(p++) = vert_num + 3;
|
|
vert_num += 4;
|
|
}
|
|
|
|
ctx->rectangle_short_indices
|
|
= cogl_indices_new (ctx,
|
|
COGL_INDICES_TYPE_UNSIGNED_SHORT,
|
|
short_array,
|
|
ctx->rectangle_short_indices_len);
|
|
|
|
g_free (short_array);
|
|
}
|
|
|
|
return ctx->rectangle_short_indices;
|
|
}
|
|
}
|
|
|