Sur cette page

QRhiTexture Class

Ressource de texture. Plus d'informations...

En-tête : #include <rhi/qrhi.h>
CMake : find_package(Qt6 REQUIRED COMPONENTS GuiPrivate)
target_link_libraries(mytarget PRIVATE Qt6::GuiPrivate)
qmake : QT += gui-private
Depuis : Qt 6.6
Hérite : QRhiResource

Types publics

struct NativeTexture
(since 6.8) struct ViewFormat
enum Flag { RenderTarget, CubeMap, MipMapped, sRGB, UsedAsTransferSource, …, UsedAsShadingRateMap }
flags Flags
enum Format { UnknownFormat, RGBA8, BGRA8, R8, RG8, …, RGBA32SI }

Fonctions publiques

int arrayRangeLength() const
int arrayRangeStart() const
int arraySize() const
virtual bool create() = 0
virtual bool createFrom(QRhiTexture::NativeTexture src)
int depth() const
QRhiTexture::Flags flags() const
QRhiTexture::Format format() const
virtual QRhiTexture::NativeTexture nativeTexture()
QSize pixelSize() const
(since 6.8) QRhiTexture::ViewFormat readViewFormat() const
int sampleCount() const
void setArrayRange(int startIndex, int count)
void setArraySize(int arraySize)
void setDepth(int depth)
void setFlags(QRhiTexture::Flags f)
void setFormat(QRhiTexture::Format fmt)
virtual void setNativeLayout(int layout)
void setPixelSize(const QSize &sz)
(since 6.8) void setReadViewFormat(const QRhiTexture::ViewFormat &fmt)
void setSampleCount(int s)
(since 6.8) void setWriteViewFormat(const QRhiTexture::ViewFormat &fmt)
(since 6.8) QRhiTexture::ViewFormat writeViewFormat() const

Fonctions publiques réimplémentées

virtual QRhiResource::Type resourceType() const override

Description détaillée

Une QRhiTexture encapsule un objet de texture natif, tel que VkImage ou MTLTexture.

Une instance de QRhiTexture est toujours créée en appelant the QRhi's newTexture() function. Cela ne crée aucune ressource graphique native. Pour ce faire, appelez create() après avoir défini les options appropriées, telles que le format et la taille, bien que dans la plupart des cas, ces options soient déjà définies en fonction des arguments passés à newTexture().

Il est essentiel de paramétrer correctement flags, faute de quoi diverses erreurs peuvent se produire en fonction du backend QRhi et de l'API graphique sous-jacents. Par exemple, lorsqu'une texture sera rendue à partir d'une passe de rendu via QRhiTextureRenderTarget, la texture doit être créée avec le drapeau RenderTarget activé. De même, lorsque la texture est destinée à être rendue via read back, l'indicateur UsedAsTransferSource doit être activé dès le départ. Pour les textures Mipmap, l'indicateur MipMapped doit être activé. Et ainsi de suite. Il n'est pas possible de modifier les drapeaux une fois que create() a réussi. Pour libérer l'objet existant et créer un nouvel objet texture natif avec les paramètres modifiés, il faut appeler les setters et appeler à nouveau create(). Il s'agit alors d'une opération potentiellement coûteuse.

Exemple d'utilisation

Créer une texture 2D d'une taille de 512x512 pixels et définir son contenu comme étant entièrement vert :

QRhiTexture *texture = rhi->newTexture(QRhiTexture::RGBA8, QSize(512, 512));
if (!texture->create()) { error(); }
QRhiResourceUpdateBatch *batch = rhi->nextResourceUpdateBatch();
QImage image(512, 512, QImage::Format_RGBA8888);
image.fill(Qt::green);
batch->uploadTexture(texture, image);
// ...
commandBuffer->resourceUpdate(batch); // or, alternatively, pass 'batch' to a beginPass() call

Modèles courants

Un appel à create() détruit toutes les ressources natives existantes si create() a été appelé avec succès auparavant. Si ces ressources natives sont encore utilisées par une image en vol (c'est-à-dire qu'il y a une chance qu'elles soient encore lues par le GPU), la destruction de ces ressources est automatiquement différée. Ainsi, un modèle très courant et pratique pour modifier en toute sécurité la taille d'une texture déjà existante est le suivant. En pratique, cette opération supprime et crée une toute nouvelle ressource de texture native, ce qui n'est pas nécessairement une opération bon marché, mais elle est plus pratique et plus rapide que les autres solutions, car en ne détruisant pas l'objet texture lui-même, toutes les références à cet objet restent valides dans d'autres structures de données (par exemple, dans n'importe quel QShaderResourceBinding auquel la QRhiTexture est référencée).

// determine newSize, e.g. based on the swapchain's output size or other factors
if (texture->pixelSize() != newSize) {
    texture->setPixelSize(newSize);
    if (!texture->create()) { error(); }
}
// continue using texture, fill it with new data

Remarque : il s'agit d'une API RHI avec des garanties de compatibilité limitées, voir QRhi pour plus de détails.

Voir également QRhiResourceUpdateBatch, QRhi, et QRhiTextureRenderTarget.

Documentation des types de membres

enum QRhiTexture::Flag
flags QRhiTexture::Flags

Valeurs des drapeaux pour spécifier comment la texture va être utilisée. Ne pas respecter les drapeaux définis avant create() et tenter d'utiliser la texture d'une manière qui n'a pas été déclarée en amont peut conduire à un comportement non spécifié ou à une diminution des performances en fonction du backend et de l'API graphique sous-jacente.

ConstanteValeurDescription de la texture
QRhiTexture::RenderTarget1 << 0La texture qui sera utilisée en combinaison avec QRhiTextureRenderTarget.
QRhiTexture::CubeMap1 << 2La texture est une cubemap. Ce type de texture comporte 6 couches, une pour chaque face dans l'ordre suivant : +X, -X, +Y, -Y, +Z, -Z. Les textures cubemap ne peuvent pas être multi-échantillonnées.
QRhiTexture::MipMapped1 << 3La texture a des mipmaps. Le nombre de mip approprié est calculé automatiquement et peut également être récupéré via QRhi::mipLevelsForSize(). Les images pour les niveaux de mip doivent être fournies dans la texture téléchargée ou générée via QRhiResourceUpdateBatch::generateMips(). Les textures multi-échantillons ne peuvent pas avoir de mipmaps.
QRhiTexture::sRGB1 << 4Utilisez un format sRGB.
QRhiTexture::UsedAsTransferSource1 << 5La texture est utilisée comme source d'une copie de texture ou d'une lecture, ce qui signifie que la texture est donnée comme source dans QRhiResourceUpdateBatch::copyTexture() ou QRhiResourceUpdateBatch::readBackTexture().
QRhiTexture::UsedWithGenerateMips1 << 6La texture sera utilisée avec QRhiResourceUpdateBatch::generateMips().
QRhiTexture::UsedWithLoadStore1 << 7La texture va être utilisée avec des opérations de chargement/stockage d'images, par exemple, dans un shader de calcul.
QRhiTexture::UsedAsCompressedAtlas1 << 8La texture a un format compressé et les dimensions des sous-ressources téléchargées peuvent ne pas correspondre à la taille de la texture.
QRhiTexture::ExternalOES1 << 9La texture doit utiliser la cible GL_TEXTURE_EXTERNAL_OES avec OpenGL. Ce drapeau est ignoré avec les autres API graphiques.
QRhiTexture::ThreeDimensional1 << 10La texture est une texture 3D. De telles textures doivent être créées avec la surcharge QRhi::newTexture() en prenant une profondeur en plus de la largeur et de la hauteur. Une texture 3D peut avoir des mipmaps mais ne peut pas être multi-échantillonnée. Lors du rendu ou du téléchargement de données dans une texture 3D, la valeur layer spécifiée dans l'attachement de couleur de la cible de rendu ou dans la description du téléchargement se réfère à une seule tranche dans l'intervalle [0..depth-1]. L'API graphique sous-jacente peut ne pas prendre en charge les textures 3D au moment de l'exécution. La prise en charge est indiquée par la fonctionnalité QRhi::ThreeDimensionalTextures.
QRhiTexture::TextureRectangleGL1 << 11La texture doit utiliser la cible GL_TEXTURE_RECTANGLE avec OpenGL. Ce drapeau est ignoré avec les autres API graphiques. Tout comme ExternalOES, ce drapeau est utile lorsque l'on travaille avec des API de plateforme où les objets de texture OpenGL natifs reçus de la plateforme sont enveloppés dans un QRhiTexture, et la plateforme ne peut fournir des textures que pour une cible de texture non 2D.
QRhiTexture::TextureArray1 << 12La texture est un tableau de textures, c'est-à-dire un objet de texture unique qui est un tableau homogène de textures 2D. Les tableaux de textures sont créés à l'aide de QRhi::newTextureArray(). L'API graphique sous-jacente peut ne pas prendre en charge les objets de type tableau de textures au moment de l'exécution. La prise en charge est indiquée par la fonction QRhi::TextureArrays. Lors du rendu ou du téléchargement de données dans un tableau de textures, la page layer spécifiée dans l'attachement de couleur de la cible de rendu ou dans la description du téléchargement sélectionne un seul élément dans le tableau.
QRhiTexture::OneDimensional1 << 13La texture est une texture 1D. De telles textures peuvent être créées en passant une hauteur et une profondeur de 0 à QRhi::newTexture(). Notez que les textures unidimensionnelles peuvent être limitées en fonction de l'API graphique sous-jacente. Par exemple, le rendu vers ces textures ou leur utilisation avec un filtrage basé sur une mipmap peut ne pas être pris en charge. Cela est indiqué par les drapeaux de fonctionnalité QRhi::OneDimensionalTextures et QRhi::OneDimensionalTextureMipmaps.
QRhiTexture::UsedAsShadingRateMap1 << 14

Le type Flags est un typedef pour QFlags<Flag>. Il stocke une combinaison OU de valeurs de drapeaux.

enum QRhiTexture::Format

Spécifie le format de la texture. Voir également QRhi::isTextureFormatSupported() et noter que flags() peut modifier le format lorsque QRhiTexture::sRGB est défini.

ConstanteValeurDescription
QRhiTexture::UnknownFormat0Format non valide. Il ne peut pas être transmis à setFormat().
QRhiTexture::RGBA81Quatre composants, 8 bits normalisés non signés par composant. Toujours pris en charge. (32 bits au total)
QRhiTexture::BGRA82Quatre composants, 8 bits normalisés non signés par composant. (32 bits au total)
QRhiTexture::R83Un composant, 8 bits normalisés non signés. (8 bits au total)
QRhiTexture::RG84Deux composants, 8 bits normalisés non signés. (16 bits au total)
QRhiTexture::R165Un composant, normalisé non signé 16 bits. (16 bits au total)
QRhiTexture::RG166Deux composants, normalisés non signés sur 16 bits. (32 bits au total)
QRhiTexture::RED_OR_ALPHA87Soit identique à R8, soit dans un format similaire avec la composante ramenée à alpha, en fonction de RedOrAlpha8IsRed. (8 bits au total)
QRhiTexture::RGBA16F8Quatre composantes, flottant 16 bits. (64 bits au total)
QRhiTexture::RGBA32F9Quatre composants, flottant 32 bits. (128 bits au total)
QRhiTexture::R16F10Un composant, flottant 16 bits. (16 bits au total)
QRhiTexture::R32F11Un composant, flottant 32 bits. (32 bits au total)
QRhiTexture::RGB10A212Quatre composants, non signés normalisés 10 bits R, G et B, 2 bits alpha. Comme il s'agit d'un format compacté, l'endianage natif s'applique. Notez qu'il n'y a pas de BGR10A2. C'est parce que RGB10A2 correspond à DXGI_FORMAT_R10G10B10A2_UNORM avec D3D, MTLPixelFormatRGB10A2Unorm avec Metal, VK_FORMAT_A2B10G10R10_UNORM_PACK32 avec Vulkan, et GL_RGB10_A2/GL_RGB/GL_UNSIGNED_INT_2_10_10_10_10_10_REV sur OpenGL (ES). Il s'agit de la seule option RGB30 universellement supportée. Les formats QImage correspondants sont QImage::Format_BGR30 et QImage::Format_A2BGR30_Premultiplied(32 bits au total).
QRhiTexture::D1621Profondeur 16 bits (entier non signé normalisé)
QRhiTexture::D2422Profondeur 24 bits (entier non signé normalisé)
QRhiTexture::D24S823Profondeur 24 bits (entier non signé normalisé), pochoir 8 bits
QRhiTexture::D32F24Profondeur 32 bits (32 bits flottants)
QRhiTexture::D32FS8 (since Qt 6.9)25Profondeur de 32 bits (32 bits flottants), 8 bits d'empreinte, 24 bits inutilisés (64 bits au total)
QRhiTexture::BC126
QRhiTexture::BC227
QRhiTexture::BC328
QRhiTexture::BC429
QRhiTexture::BC530
QRhiTexture::BC6H31
QRhiTexture::BC732
QRhiTexture::ETC2_RGB833
QRhiTexture::ETC2_RGB8A134
QRhiTexture::ETC2_RGBA835
QRhiTexture::ASTC_4x436
QRhiTexture::ASTC_5x437
QRhiTexture::ASTC_5x538
QRhiTexture::ASTC_6x539
QRhiTexture::ASTC_6x640
QRhiTexture::ASTC_8x541
QRhiTexture::ASTC_8x642
QRhiTexture::ASTC_8x843
QRhiTexture::ASTC_10x544
QRhiTexture::ASTC_10x645
QRhiTexture::ASTC_10x846
QRhiTexture::ASTC_10x1047
QRhiTexture::ASTC_12x1048
QRhiTexture::ASTC_12x1249
QRhiTexture::R8UI (since Qt 6.9)17Un composant, 8 bits non signés. (8 bits au total)
QRhiTexture::R32UI (since Qt 6.9)18Un composant, non signé 32 bits. (32 bits au total)
QRhiTexture::RG32UI (since Qt 6.9)19Deux composants, non signés 32 bits. (64 bits au total)
QRhiTexture::RGBA32UI (since Qt 6.9)20Quatre composants, non signés 32 bits. (128 bits au total)
QRhiTexture::R8SI (since Qt 6.10)13Un composant, signé 8 bits. (8 bits au total)
QRhiTexture::R32SI (since Qt 6.10)14Un composant, signé 32 bits. (32 bits au total)
QRhiTexture::RG32SI (since Qt 6.10)15Deux composants, signés 32 bits. (64 bits au total)
QRhiTexture::RGBA32SI (since Qt 6.10)16Quatre composants, signés 32 bits. (128 bits au total)

Documentation des fonctions membres

int QRhiTexture::arrayRangeLength() const

Renvoie la taille de la plage de tableaux exposée lorsque setArrayRange() a été appelé.

Voir aussi setArrayRange().

int QRhiTexture::arrayRangeStart() const

Renvoie la première couche du tableau lorsque setArrayRange() a été appelé.

Voir aussi setArrayRange().

int QRhiTexture::arraySize() const

Renvoie la taille du tableau de textures.

Voir aussi setArraySize().

[pure virtual] bool QRhiTexture::create()

Crée les ressources graphiques natives correspondantes. Si des ressources sont déjà présentes en raison d'un create() antérieur sans destroy() correspondant, alors destroy() est appelé implicitement en premier.

Retourne true en cas de succès, false en cas d'échec de l'opération graphique. Quelle que soit la valeur de retour, l'appel à destroy() est toujours sûr.

[virtual] bool QRhiTexture::createFrom(QRhiTexture::NativeTexture src)

Similaire à create(), sauf qu'aucune nouvelle texture native n'est créée. Au lieu de cela, les ressources de textures natives spécifiées par src sont utilisées.

Cela permet d'importer un objet de texture natif existant (qui doit appartenir au même périphérique ou contexte de partage, en fonction de l'API graphique) à partir d'un moteur graphique externe.

Retourne vrai si l'objet de texture natif spécifié a été enveloppé avec succès en tant qu'objet non propriétaire QRhiTexture.

Remarque : format(), pixelSize(), sampleCount() et flags() doivent toujours être définis correctement. Transmettre des tailles incorrectes et d'autres valeurs à QRhi::newTexture(), puis le faire suivre d'un createFrom() en pensant que l'objet texture natif est suffisant pour déduire ces valeurs, est une erreur et conduira à des problèmes.

Remarque : QRhiTexture ne prend pas possession de l'objet texture. destroy() ne libère pas l'objet ni la mémoire associée.

L'inverse de cette opération, à savoir l'exposition d'un objet de texture natif créé par QRhiTexture à un moteur étranger, est possible via nativeTexture().

Note : Lors de l'importation d'une texture 3D, ou d'un objet de type tableau de textures, ou, avec OpenGL ES, d'une texture externe, il est particulièrement important d'activer les drapeaux correspondants (ThreeDimensional, TextureArray, ExternalOES) via setFlags() avant d'appeler cette fonction.

int QRhiTexture::depth() const

Renvoie la profondeur des textures 3D.

Voir également setDepth().

QRhiTexture::Flags QRhiTexture::flags() const

Renvoie les drapeaux de texture.

Voir aussi setFlags().

QRhiTexture::Format QRhiTexture::format() const

Renvoie le format de la texture.

Voir aussi setFormat().

[virtual] QRhiTexture::NativeTexture QRhiTexture::nativeTexture()

Renvoie les ressources natives sous-jacentes pour cette texture. La valeur retournée sera vide si l'exposition des ressources natives sous-jacentes n'est pas prise en charge par le backend.

Voir aussi createFrom().

QSize QRhiTexture::pixelSize() const

Renvoie la taille en pixels.

Voir aussi setPixelSize().

[since 6.8] QRhiTexture::ViewFormat QRhiTexture::readViewFormat() const

Renvoie le format de vue utilisé lors de l'échantillonnage de la texture. S'il n'est pas appelé, le format d'affichage est supposé être le même que celui de format().

Cette fonction a été introduite dans Qt 6.8.

Voir aussi setReadViewFormat().

[override virtual] QRhiResource::Type QRhiTexture::resourceType() const

Réimplémente : QRhiResource::resourceType() const.

Renvoie le type de ressource.

int QRhiTexture::sampleCount() const

Renvoie le nombre d'échantillons. 1 signifie qu'il n'y a pas d'anti-crénelage multi-échantillon.

Voir aussi setSampleCount().

void QRhiTexture::setArrayRange(int startIndex, int count)

Normalement, toutes les couches du tableau sont exposées et il appartient au nuanceur de sélectionner la couche via la troisième coordonnée transmise à la fonction GLSL texture() lors de l'échantillonnage du tableau sampler2DArray. Lorsque QRhi::TextureArrayRange est signalé comme étant pris en charge, l'appel à setArrayRange() avant create() ou createFrom() demande de ne sélectionner que la plage spécifiée, les éléments count commençant à startIndex. La logique du nuanceur peut alors être écrite en gardant cela à l'esprit.

Voir également QRhi::TextureArrayRange.

void QRhiTexture::setArraySize(int arraySize)

Définit la texture arraySize.

Voir aussi arraySize().

void QRhiTexture::setDepth(int depth)

Définit le site depth pour une texture 3D.

Voir également depth().

void QRhiTexture::setFlags(QRhiTexture::Flags f)

Définit les drapeaux de texture à f.

Voir aussi flags().

void QRhiTexture::setFormat(QRhiTexture::Format fmt)

Définit le format de texture demandé à fmt.

Remarque : la valeur définie n'est prise en compte que lors du prochain appel à create(), c'est-à-dire lorsque les ressources graphiques sous-jacentes sont (re)créées. La définition d'une nouvelle valeur est futile dans le cas contraire et doit être évitée car elle peut conduire à un état incohérent.

Voir également format().

[virtual] void QRhiTexture::setNativeLayout(int layout)

Avec certaines API graphiques, telles que Vulkan, l'intégration d'un code de rendu personnalisé qui utilise directement l'API graphique doit faire l'objet d'une attention particulière en ce qui concerne la mise en page des images. Cette fonction permet de communiquer l'adresse layout prévue pour l'image sauvegardée sur le site QRhiTexture après les commandes de rendu natives.

Par exemple, considérons le rendu dans une QRhiTexture's VkImage directement avec Vulkan dans un bloc de code entouré par QRhiCommandBuffer::beginExternal() et QRhiCommandBuffer::endExternal(), suivi de l'utilisation de l'image pour l'échantillonnage de texture dans une passe de rendu basée sur QRhi. Pour éviter des transitions potentiellement incorrectes dans la disposition de l'image, cette fonction peut être utilisée pour indiquer quelle sera la disposition de l'image une fois que les commandes enregistrées dans ledit bloc de code seront terminées.

L'appel à cette fonction n'a de sens qu'après QRhiCommandBuffer::endExternal() et avant QRhiCommandBuffer::beginPass().

Cette fonction n'a aucun effet avec les backends QRhi où l'API graphique sous-jacente n'expose pas de concept de disposition d'image.

Remarque : avec Vulkan, layout est une valeur VkImageLayout. Avec Direct 3D 12, layout est une valeur composée des bits de D3D12_RESOURCE_STATES.

void QRhiTexture::setPixelSize(const QSize &sz)

Fixe la taille de la texture, spécifiée en pixels, à sz.

Remarque : la valeur définie n'est prise en compte que lors du prochain appel à create(), c'est-à-dire lorsque les ressources graphiques sous-jacentes sont (re)créées. Définir une nouvelle valeur est futile dans le cas contraire et doit être évité car cela peut conduire à un état incohérent. Il en va de même pour tous les autres setters.

Voir également pixelSize().

[since 6.8] void QRhiTexture::setReadViewFormat(const QRhiTexture::ViewFormat &fmt)

Définit le format de la vue de la ressource du shader (ou le format de la vue utilisée pour l'échantillonnage de la texture) à fmt. Par défaut, le même format (et le caractère sRGB) est utilisé que la texture elle-même, et dans la plupart des cas, cette fonction n'a pas besoin d'être appelée.

Ce paramètre n'est pris en compte que lorsque la fonctionnalité QRhi::TextureViewFormat est signalée comme étant prise en charge.

Remarque : cette fonctionnalité est fournie pour permettre le "casting" entre non-sRGB et sRGB afin que le shader lise ou non les conversions sRGB implicites. D'autres types de conversion peuvent être fonctionnels ou non.

Cette fonction a été introduite dans Qt 6.8.

Voir aussi readViewFormat().

void QRhiTexture::setSampleCount(int s)

Fixe le nombre d'échantillons à s.

Voir aussi sampleCount().

[since 6.8] void QRhiTexture::setWriteViewFormat(const QRhiTexture::ViewFormat &fmt)

Définit le format de vue de la cible de rendu à fmt. Par défaut, le même format (et le caractère sRGB) est utilisé que la texture elle-même, et dans la plupart des cas, cette fonction n'a pas besoin d'être appelée.

Un cas d'utilisation courant pour fournir un format de vue d'écriture est de travailler avec des textures fournies en externe qui, en dehors de notre contrôle, utilisent un format sRGB avec des API 3D telles que Vulkan ou Direct 3D, mais le moteur de rendu est déjà prêt à gérer la linéarisation et la conversion en sRGB à la fin de son pipeline d'ombrage. Dans ce cas, ce que l'on souhaite obtenir lors du rendu d'une telle texture, c'est une vue cible de rendu (par exemple VkImageView) qui a le même format, mais qui n'est pas RVB. (si, par exemple, une implémentation OpenXR permet d'obtenir une texture VK_FORMAT_R8G8B8A8_SRGB, il est probable que le rendu dans cette texture devrait être effectué en utilisant une vue VK_FORMAT_R8G8B8A8_UNORM, si c'est ce que le pipeline du moteur de rendu exige ; dans cet exemple, on appellerait cette fonction avec une vue ViewFormat dont le format est QRhiTexture::RGBA8 et srgb réglé sur false).

Ce paramètre n'est pris en compte que lorsque la fonctionnalité QRhi::TextureViewFormat est signalée comme étant prise en charge.

Remarque : cette fonctionnalité est fournie pour permettre le "casting" entre non-sRGB et sRGB afin que l'écriture du shader n'effectue pas, ou effectue, les conversions sRGB implicites. D'autres types de conversion peuvent être fonctionnels ou non.

Cette fonction a été introduite dans Qt 6.8.

Voir aussi writeViewFormat().

[since 6.8] QRhiTexture::ViewFormat QRhiTexture::writeViewFormat() const

Renvoie le format d'affichage utilisé lors de l'écriture dans la texture et lors de son utilisation avec le chargement/stockage d'images. S'il n'est pas appelé, le format d'affichage est supposé être le même que celui de format().

Cette fonction a été introduite dans Qt 6.8.

Voir aussi setWriteViewFormat().

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.