summaryrefslogtreecommitdiff
path: root/gsk/ngl/gskngltexture.c
blob: c70d4d91b21391f5a36a3fdec324609fcf49c41d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
/* gskngltexture.c
 *
 * Copyright 2020 Christian Hergert <chergert@redhat.com>
 *
 * This file is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free
 * Software Foundation; either version 2.1 of the License, or (at your option)
 * any later version.
 *
 * This file is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */

#include "config.h"

#include <gdk/gdktextureprivate.h>

#include "gskngltextureprivate.h"
#include "ninesliceprivate.h"

void
gsk_ngl_texture_free (GskNglTexture *texture)
{
  if (texture != NULL)
    {
      g_assert (texture->link.prev == NULL);
      g_assert (texture->link.next == NULL);

      if (texture->user)
        g_clear_pointer (&texture->user, gdk_texture_clear_render_data);

      if (texture->texture_id != 0)
        {
          glDeleteTextures (1, &texture->texture_id);
          texture->texture_id = 0;
        }

      for (guint i = 0; i < texture->n_slices; i++)
        {
          glDeleteTextures (1, &texture->slices[i].texture_id);
          texture->slices[i].texture_id = 0;
        }

      g_clear_pointer (&texture->slices, g_free);
      g_clear_pointer (&texture->nine_slice, g_free);

      g_slice_free (GskNglTexture, texture);
    }
}

GskNglTexture *
gsk_ngl_texture_new (guint  texture_id,
                     int    width,
                     int    height,
                     int    format,
                     int    min_filter,
                     int    mag_filter,
                     gint64 frame_id)
{
  GskNglTexture *texture;

  texture = g_slice_new0 (GskNglTexture);
  texture->texture_id = texture_id;
  texture->link.data = texture;
  texture->min_filter = min_filter;
  texture->mag_filter = mag_filter;
  texture->format = format;
  texture->width = width;
  texture->height = height;
  texture->last_used_in_frame = frame_id;

  return texture;
}

const GskNglTextureNineSlice *
gsk_ngl_texture_get_nine_slice (GskNglTexture        *texture,
                                const GskRoundedRect *outline,
                                float                 extra_pixels_x,
                                float                 extra_pixels_y)
{
  g_assert (texture != NULL);
  g_assert (outline != NULL);

  if G_UNLIKELY (texture->nine_slice == NULL)
    {
      texture->nine_slice = g_new0 (GskNglTextureNineSlice, 9);

      nine_slice_rounded_rect (texture->nine_slice, outline);
      nine_slice_grow (texture->nine_slice, extra_pixels_x, extra_pixels_y);
      nine_slice_to_texture_coords (texture->nine_slice, texture->width, texture->height);
    }

  return texture->nine_slice;
}