text
stringlengths 1
22.8M
|
|---|
Dad's in Heaven with Nixon is a 2010 documentary film produced, directed and written by Tom Murray. It concerns the history of the Murray family and especially of Tom's brother Chris Murray, a man with autism whose paintings of cityscapes, first promoted by family friend Gloria Vanderbilt, have garnered widespread praise. The title refers to Chris' belief that his late father, who loathed Richard Nixon, is now friends in heaven with the former president. Ranging over three generations of Murrays, whose patriarchs struggled with alcoholism and bipolar disorder, the film treats of subjects ranging from father-son relationships to the Great Depression, from the effects of divorce on families to the cushy lifestyle of the residents of Southampton, New York.
See also
Golden Clan, a non-fiction account of the Murray / McDonnell family of New York, by John Corry
Thomas E. Murray, the great-grandfather of Tom and Christopher Murray
List of films about Autism
Autism spectrum disorders in the media
Autism: The Musical
The Horse Boy
Recovered: Journeys Through the Autism Spectrum and Back
References
External links
The New York Times review
Bloomberg review
Documentary films about autism
Documentary films about painters
Works about outsider art
2010 films
2010 documentary films
American documentary films
2010s English-language films
2010s American films
Films about disability
|
Sitio Conte is an archaeological site located in the Coclé province of Panama near Parita Bay. It can best be described as a necropolis and a "paradigmatic example of a ranked or chiefdom society". Based on dates from the goldwork and polychrome ceramics found at the site, its use is dated from approximately AD 450–900. While the site has remained untouched since the final excavations in 1940, its mortuary remains are considered to be a critical resource to archaeologists, as they aid in the interpretation of the social dynamics in the region between AD 500 and 1500.
Site organization
The site itself is located on the eastern bank of the Rio Grande de Coclé. From its core, it spreads east, north and south along the river. Surrounding the site are grasslands and a number of small hills. To the north of Sitio Conte are the Tabasará Mountains; to the south lies Parita Bay.
The most significant features at the site are the graves themselves. Architectural features are few in number and include two rows of large, roughly shaped vertical stones that measured 2 meters in height. These were associated with smaller stones with flat tops, which archaeologist Samuel Kirkland Lothrop referred to as "altars". Also included among these features were two floors and a large pile of roughly worked stones.
A brief history
Little is known about Sitio Conte and the individuals who are interred therein. A number of theories as to the function of the site have been offered, ranging from a "summer residence," to a shared burial ground. Those interred within the graves have been identified as either "chiefly families" or "chiefs and warriors slain in a single battle".
Archaeologists have a good understanding as to when the site was in use, ascertained by dates associated with the goldwork and polychrome ceramics in the graves. From these artifacts, it has been revealed that the site was used from approximately AD 450 to 900. Around AD 900, the cemetery was abandoned; however, based on household refuse, it appears that domestic occupation of the site continued.
Archaeology at Sitio Conte
Towards the end of the nineteenth century, the Rio Grande de Coclé changed course and began to cut through the western edge of the site. In doing so, it washed a number of artifacts down stream, which were later collected and sold. Some objects were displayed by the Panamanian government during the opening of the Panama Canal in 1915. In 1927, the river changed course once again, sending more objects downstream.
In 1928, the Conte family excavated a pit, which revealed some of the large stone columns that Lothrop later referred to in his reports. Several of these objects found their way to the Peabody Museum of Harvard University, drawing the interest of then curator, Alfred M. Tozzer. Tozzer and Earnest A. Hooten visited the site in that same year and made arrangements for excavations by the Peabody Museum.
In 1930, when excavations began under the direction of archaeologist Henry Roberts, Sitio Conte became the "first site to receive scientific field study in Panama". Roberts led the excavations the following year as well. In 1933, the Peabody Museum returned under the direction of Samuel K. Lothrop. All three seasons of the Peabody excavations were successful, as 59 graves and 38 "caches" were discovered, as well as a large number of gold objects and polychrome ceramics.
In the late 1930s, the Conte family asked the Peabody Museum to return for further excavations, a request that was denied by director Donald Scott. Instead, it was suggested that J. Alden Mason of the University Museum of Archaeology and Anthropology (the Penn Museum) in Philadelphia continue the excavations. In 1940, Mason and his colleagues carried out another successful excavation, uncovering 41 graves, which included a large number of grave goods. This was to be the last excavation at the site.
The excavations of both the Peabody Museum and the University Museum have been criticized for the manner in which they were conducted. Most criticisms are aimed at the archaeologists' decisions to forego any stratigraphic investigations at the site. Olga Linares felt that "good stratigraphic control was sacrificed for expediency. Others have criticized their work for "both lack of control over artifact recording and unclear field notes".
The archaeologists who excavated Sitio Conte found 228 dogs buried at the site, along with many teeth that used for decorative purposes, for example, as beads on the apron found in the burial remains of an elite woman. Katherine B. Moore of the University of Pennsylvania has analyzed these dog teeth decorations, showing that they came from a single breed and pointing to them as evidence for the entry of dogs into South America and their domestication.
Prominent graves
Grave 1
Grave 1 is considered to be one of the more prominent unearthed during the Peabody excavation. It dates to AD 400-500. Those who were interred have been interpreted to be a "chief and three of his retainers". The primary occupant, skeleton 1, was interred in a seated position and lavishly adorned with grave goods. Among these were eight effigy vessels and 112 plates or bowls, all of which were spread along the edge of the grave.
Also included were gold or tumbaga beads, pendants, greaves and chisels, a canine teeth apron, mirror backs, whale teeth and carved manatee ribs with gold overlay, seventeen hundred serpentine beads and several bundles of stingray spines. Skeleton two also had many of these same objects in association, as well as a small quantity of celts and stone blades. The remaining skeletons had similar grave goods, although fewer in number.
Grave 5
Dating to around AD 700/800-900, Grave 5 contained fifteen skeletons and a number of grave goods. Interred in the seated position, the primary skeleton (15) was originally housed in a "makeshift hut," that had long since decomposed. His grave goods included a carved whale tooth pendant, stone mirror backs, gold or tumbaga greaves, cuffs, plaques and a helmet. On the floor were stone slabs, tortoise shells and various ceramics.
Of the other fourteen skeletons that were included in the grave, eight were located along the south and west sides of the grave and the other six were found on the northern edge. Lothrop felt that the northern group likely belonged to an earlier burial. Some of their grave goods included bone, gold and stone pendants.
Grave 26
One of the richest graves of the Peabody excavations, Grave 26 contained 22 skeletons and dates to the same period as Grave 5. The primary occupant, skeleton 12, was interred in a seated position and was once enclosed in a makeshift hut. Forming the floor of the grave were a number of ceramics, a stone slab and the remainder of the grave's occupants.
Some of the grave goods that are associated with the primary interment include gold or tumbaga plaques, cuffs, greaves, beads, carved whale teeth and manatee ribs, stingray spines and an emerald. Of the 126 ceramic pieces found in Grave 26, a majority of them lined the walls of the grave. These included thirty-six effigy vessels and ninety polychrome plates. The other occupants had a few grave goods, including several gold ear rods, which were associated with Skeleton 8.
Grave 74
Excavated during the 1940 expedition led by J. Alden Mason, Grave 74 dates to AD 700/800-900 and is one of richest known graves at Sitio Conte. The primary occupants, skeletons 15 and 16, were found lying on top of one another in the center of the middle layer. Also known as Burial 11, this grave contained over 7500 mortuary furnishings, as well as twenty-three interments that were placed on three levels.
Upper level
As Mason and his team were digging, they uncovered eight skeletons, all of which were lying face down and parallel to one another. Six of these skeletons were identified as old or mature males, while the other two were unsexed. Among their grave goods were ceramics, stone projectile points, celts, and a winged agate pendant. Skeleton 4 had a cache of stone points at its feet, a cache of gold beads and five repoussé gold plaques, which lay atop the individual. Intact vessels and ceramic sherds lined the north and south ends of the burial, which continued down into the second level.
Middle level
Proceeding further into the excavation, the team began to reveal a 2nd level of burials. This level contained twelve skeletons that were accompanied by thousands of grave goods. The primary occupants of the grave, skeletons 15 and 16, were located in the center of this level with five skeletons on the pair's east side, three on the west and single skeletons on the north and south ends.
Associated with the central individuals were a large number of grave goods, including a large number of repoussé and plain gold plaques, ear rods, bells, greaves and beads. There were also a number of stone projectile points and celts. The most famous of the goods associated with these individuals is the cast gold composite effigy animal pendant with an emerald embedded in its back. This was found lying bottom up atop the gold plaques that covered the two central individuals.
Numerous items were placed with the other occupants of this grave: gold triangles, a pair of whale teeth, a carved figure covered with gold, canine teeth, several green projectile points and a stone celt.
It was on this level that the "ceramic wall" reached both its thickest point, 30 centimeters, and its end. The excavators began to become overwhelmed by the large quantity of ceramics and removed many of the vessels without recording any information. Mason (n.d.: 64) noted that the field team got "gold fever" and "were anxious to get [the] vessels removed from above [the] gold objects, so began removing vessels before making list".
Lower level
After clearing the second level, the team reached the lowest point of the grave. As they removed the layer of ceramic sherds and surrounding dirt, they uncovered three skeletons. The individual in the center, skeleton 21, lay on its side, while the other two lay face down. Two of the skeletons, 21 and 22, had a few objects associated with them, including a gold bat effigy pendant, ear rods, some stone celts, and a large embossed gold plaque.
The art of Sitio Conte
The iconography of the gold and ceramic pieces at Sitio Conte reflects a highly refined artistry. While some figures are abstract representations of animals, others appear to be therianthropic in nature. These figures mostly appear in two basic designs, single or paired. There are exceptions to this as some ceramics contain multiple images as well.
The iconography of the gold pieces varies from animals such as bats, deer, sharks, crocodiles, and saurians to human and therianthropic figures. Many of these subjects are represented in the iconography of the Coclé style ceramics that appear within the burials. They also include images of snakes, birds, turtles, crabs, insects, frogs, stingrays, armadillos and monkeys. It has been suggested that the inclusion of these gold and ceramic pieces may represent the rank of the individuals with whom they are associated.
Sitio Conte today
Sitio Conte has remained untouched by professional archaeologists since Mason's only season in 1940. The land where the site is located belongs to the Conte family of Coclé, and is currently in use as agricultural fields.
References
Bibliography
Benson, Elizabeth P. (1992) "Motifs, Meanings, and Myths: The Iconography of Sitio Conte Gold Plaques" in River of Gold – Precolumbian Treasures from Sitio Conte. Eds: Hearne, Pamela and Robert J. Sharer Philadelphia: University Museum, University of Pennsylvania.
Bray, Warwick (1992) "Sitio Conte Metalwork in its Pan-American Context" in River of Gold – Precolumbian Treasures from Sitio Conte. Eds: Hearne, Pamela and Robert J. Sharer Philadelphia: University Museum, University of Pennsylvania.
Briggs, Peter S. (1989) Art, Death, and Social Order: The Mortuary Arts of Pre-Conquest Central Panama. BAR international series, 550. Oxford, England: B.A.R.
Cooke, Richard G. (1976) Panama: Region Central. Vinculos, 2:122–140.
Hearne, Pamela (1992) "The Story of the River of Gold" in River of Gold—Precolumbian Treasures from Sitio Conte. Eds: Hearne, Pamela and Robert J. Sharer Philadelphia: University Museum, University of Pennsylvania.
Linares, Olga F. (1977) "Ecology and the arts in ancient Panama: On the development of social rank and symbolism in the central provinces." in Studies in pre-Columbian art and archaeology, no. 17. Washington: Dumbarton Oaks, Trustees for Harvard University.
Lothrop, Samuel K. (1937) Coclé, an archaeological study of central Panama, vol. 1. Cambridge: Published by the Museum.
Stirling, M. W. (1949) The Importance of Sitio Conte. American Anthropologist, 45(3), pp. 514–517.
External links
Video from the "River of Gold" exhibit from the Penn Museum
Archaeological sites in Panama
Former populated places in Panama
Pre-Columbian archaeological sites
Buildings and structures in Coclé Province
|
A morning star () is any of several medieval club-like weapons consisting of a shaft with an attached ball adorned with one or more spikes. Each used, to varying degrees, a combination of blunt-force and puncture attack to kill or wound the enemy.
History
The morning star first came into widespread use around the beginning of the fourteenth century, particularly in Germany where it was known as Morgenstern. The term is often confused with the military flail (fléau d'armes in French and Kriegsflegel in German), which typically consists of a wooden shaft joined by a length of chain to one or more iron-shod wooden bars. (Heavy sword pommels have also been used as weights.) However, there are few depictions of such a ball-and-chain flail from the period, so the weapon of this type appears to have been uncommon.
Design
The morning star is a medieval weapon consisting of a spiked ball mounted on a shaft, resembling a mace, usually with a long spike extending straight from the top and many smaller spikes around the particle of the head. The spikes distinguish it from a mace, which uses flanges or knobs to penetrate plate armor. It was used by both infantry and cavalry; the horseman's weapon had a shorter shaft. The mace was a traditional knightly weapon that developed somewhat independently; as the mace transitioned to being constructed entirely of metal, the morning star retained its characteristic wooden shaft. Many surviving morning stars are of a longer two-handed form typically six feet in length, with some longer examples.
There were three types, all differing in quality of workmanship. The first was the well-crafted military type used by professional soldiers, made in series by expert weaponsmiths for stocking in town arsenals. The second and much simpler type would have been hand-cut by peasant militia men, rather than turned on a lathe, from wood they had gathered themselves and fitted with nails and spikes by the local blacksmith. The shaft and head were usually of one piece but sometimes reinforced at the top with an iron band. The third type was decorative in nature, usually short-hafted and made of metal, one sixteenth century example being of steel and damascened with inlaid gold and silver, in the Wallace Collection of London.
Holy water sprinkler
The holy water sprinkler (from its resemblance to the aspergillum used in the Catholic Mass), was a morning star used by the English army in the sixteenth century and made in series by professional smiths. One such weapon can be found in the Royal Armouries and has an all-steel head with six flanges forming three spikes each, reminiscent of a mace but with a short thick spike of square cross section extending from the top. The wooden shaft is reinforced with four langets and the overall length of the weapon is .
The term holy water sprinkler is also used to describe a type of military flail, this being the name for the weapon in French (goupillon). It was (according to popular legend) the favored weapon of King John of Bohemia, who was blind, and used to simply lay about himself on all sides.
Examples
Two examples of the military type are housed in the museums of Vienna, both from the 16th century. The first measures in length including the top spike which is . The head is a separate wooden cylinder slipped over the top of the shaft and reinforced with steel bands, with five metal spikes in symmetrical arrangement. The second example has an all-steel head of complex craftsmanship with four V-shaped spikes mounted on a long shaft that measures slightly less than two metres in length. A twisted and braided steel bar joins the socket to the base of the top spike. There are also 183 surviving specimens in Graz, made in series and delivered to the arsenal in 1685. They are comparable in length to the previous examples and have three rows of spikes around the head. The wooden shafts of most morning stars of the military type are reinforced with metal langets extending down from the head. Still others can be found in the Swiss arsenals of Lucerne and Zurich.
In art
These types of morning stars are also depicted in medieval art. For instance, one is shown being carried by an armored knight or soldier in the Caesar Tapestries in the Historical Museum of Bern, depicting Julius Caesar's battle against the Germanic leader Ariovistus. These tapestries were woven in Tournai between 1465 and 1470, and taken as plunder from Charles the Bold after one of his defeats during the Burgundian Wars against the Swiss. In the poem Le Chevalier Délibéré written by Olivier de la Marche and first published in 1486, there is an anonymous woodcut depicting a knight carrying a rather simple morning star with spikes mounted in an asymmetrical pattern as well as a flail equipped with a single spiked ball, known in German as a "Kettenmorgenstern" (literally chain-morning star) which is technically a military flail.
Similar weapons
Goedendag
The goedendag (or variant spellings) was a Flemish weapon which is often described in modern sources as similar to the morning star. However, this is a misconception; it was an infantry weapon in the form of a thick wooden shaft between in length, slightly thicker toward the top, topped with a stout iron spike. The weapon was used to great effect by the guildsmen of Flanders' wealthy cities against the French knights during the Guldensporenslag or Battle of the Golden Spurs near Kortrijk (Courtrai) on 11 July 1302; however, on account of superior but more expensive alternatives, it saw limited service from the fifteenth century on, being used exclusively by the Flemish burghers.
The goedendag was used to spear horses or knights, but little is certain about its precise mode of use.
See also
Flail (weapon)
Pistol sword
Mace (bludgeon)
Meteor hammer
Citations
General references
Dictionary of Medieval Knighthood and Chivalry by Bradford Broughton (NY, Greenwood Press, 1986, )
Hafted Weapons in Medieval and Renaissance Europe: The Evolution of European Staff Weapons Between 1200 and 1650 by John Waldman (Brill, 2005, )
Medieval Military Technology by Kelly DeVries (Broadview Press, 1998, 0-921149-74-3)
External links
Clubs (weapon)
Medieval weapons
|
```javascript
Page({
data: {},
onLoad() {},
onShareAppMessage() {
return {
title: '',
path: 'page/weui/example/linebreak/linebreak'
}
},
})
```
|
The Comrads was American gangsta rap duo from Lynwood, California, composed of Kelly "K-Mac" Garmon and Terrell "Gangsta" Anderson. The pair made a major splash in the Los Angeles area in the summer of 1997 with the single "Homeboyz" from their self-titled debut album. The duo signed with Mack 10's Hoo-Bangin' Records and released their sophomore studio album Wake Up & Ball in 2000.
After the group split, K-Mac joined Mack 10's supergroup Da Hood to release Mack 10 Presents da Hood in 2002. Gangsta has released his solo album Penitentiary Chances via Heat Rocc Entertainment in 2003.
Discography
Albums
Singles
Guest appearances
References
Hip hop groups from California
Musical duos from California
Hip hop duos
People from Lynwood, California
|
```php
<?php
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
*/
namespace Google\Service\Dfareporting\Resource;
use Google\Service\Dfareporting\Subaccount;
use Google\Service\Dfareporting\SubaccountsListResponse;
/**
* The "subaccounts" collection of methods.
* Typical usage is:
* <code>
* $dfareportingService = new Google\Service\Dfareporting(...);
* $subaccounts = $dfareportingService->subaccounts;
* </code>
*/
class Subaccounts extends \Google\Service\Resource
{
/**
* Gets one subaccount by ID. (subaccounts.get)
*
* @param string $profileId User profile ID associated with this request.
* @param string $id Subaccount ID.
* @param array $optParams Optional parameters.
* @return Subaccount
* @throws \Google\Service\Exception
*/
public function get($profileId, $id, $optParams = [])
{
$params = ['profileId' => $profileId, 'id' => $id];
$params = array_merge($params, $optParams);
return $this->call('get', [$params], Subaccount::class);
}
/**
* Inserts a new subaccount. (subaccounts.insert)
*
* @param string $profileId User profile ID associated with this request.
* @param Subaccount $postBody
* @param array $optParams Optional parameters.
* @return Subaccount
* @throws \Google\Service\Exception
*/
public function insert($profileId, Subaccount $postBody, $optParams = [])
{
$params = ['profileId' => $profileId, 'postBody' => $postBody];
$params = array_merge($params, $optParams);
return $this->call('insert', [$params], Subaccount::class);
}
/**
* Gets a list of subaccounts, possibly filtered. This method supports paging.
* (subaccounts.listSubaccounts)
*
* @param string $profileId User profile ID associated with this request.
* @param array $optParams Optional parameters.
*
* @opt_param string ids Select only subaccounts with these IDs.
* @opt_param int maxResults Maximum number of results to return.
* @opt_param string pageToken Value of the nextPageToken from the previous
* result page.
* @opt_param string searchString Allows searching for objects by name or ID.
* Wildcards (*) are allowed. For example, "subaccount*2015" will return objects
* with names like "subaccount June 2015", "subaccount April 2015", or simply
* "subaccount 2015". Most of the searches also add wildcards implicitly at the
* start and the end of the search string. For example, a search string of
* "subaccount" will match objects with name "my subaccount", "subaccount 2015",
* or simply "subaccount" .
* @opt_param string sortField Field by which to sort the list.
* @opt_param string sortOrder Order of sorted results.
* @return SubaccountsListResponse
* @throws \Google\Service\Exception
*/
public function listSubaccounts($profileId, $optParams = [])
{
$params = ['profileId' => $profileId];
$params = array_merge($params, $optParams);
return $this->call('list', [$params], SubaccountsListResponse::class);
}
/**
* Updates an existing subaccount. This method supports patch semantics.
* (subaccounts.patch)
*
* @param string $profileId User profile ID associated with this request.
* @param string $id Required. Subaccount ID.
* @param Subaccount $postBody
* @param array $optParams Optional parameters.
* @return Subaccount
* @throws \Google\Service\Exception
*/
public function patch($profileId, $id, Subaccount $postBody, $optParams = [])
{
$params = ['profileId' => $profileId, 'id' => $id, 'postBody' => $postBody];
$params = array_merge($params, $optParams);
return $this->call('patch', [$params], Subaccount::class);
}
/**
* Updates an existing subaccount. (subaccounts.update)
*
* @param string $profileId User profile ID associated with this request.
* @param Subaccount $postBody
* @param array $optParams Optional parameters.
* @return Subaccount
* @throws \Google\Service\Exception
*/
public function update($profileId, Subaccount $postBody, $optParams = [])
{
$params = ['profileId' => $profileId, 'postBody' => $postBody];
$params = array_merge($params, $optParams);
return $this->call('update', [$params], Subaccount::class);
}
}
// Adding a class alias for backwards compatibility with the previous class name.
class_alias(Subaccounts::class, 'Google_Service_Dfareporting_Resource_Subaccounts');
```
|
Bouteville () is a commune in the Charente department in southwestern France. It contains the ruins of a medieval castle.
Population
See also
Communes of the Charente department
References
Communes of Charente
|
Bodmin St Petroc was an electoral division of Cornwall in the United Kingdom which returned one member to sit on Cornwall Council between 2013 and 2021. It was abolished at the 2021 local elections, being succeeded by the larger Bodmin St Petroc's.
Extent
Bodmin St Petroc represented the east side of Bodmin, the hamlet of Cooksland, and parts of the hamlet of Fletchersbridge (which was shared with Lanivet and Blisland). The division covered 752 hectares in total.
Election results
2017 election
2013 election
References
Electoral divisions of Cornwall Council
Bodmin
|
The Murchison meteorite is a meteorite that fell in Australia in 1969 near Murchison, Victoria. It belongs to the carbonaceous chondrite class, a group of meteorites rich in organic compounds. Due to its mass (over ) and the fact that it was an observed fall, the Murchison meteorite is one of the most studied of all meteorites.
In January 2020, cosmochemists reported that the oldest material found on Earth to date are the silicon carbide particles from the Murchison meteorite, which have been determined to be 7 billion years old, about 2.5 billion years older than the 4.54-billion-year age of the Earth and the Solar System. The published study noted that "dust lifetime estimates mainly rely on sophisticated theoretical models. These models, however, focus on the more common small dust grains and are based on assumptions with large uncertainties."
History
On 28 September 1969 at approximately 10:58 a.m. local time, near Murchison, Victoria, in Australia, a bright fireball was observed to separate into three fragments before disappearing, leaving a cloud of smoke. About 30 seconds later, a tremor was heard. Many fragments were found scattered over an area larger than , with individual mass up to ; one, weighing , broke through a roof and fell in hay. The total collected mass of the meteorite exceeds .
Classification and composition
The meteorite belongs to the CM group of carbonaceous chondrites. Like most CM chondrites, Murchison is petrologic type 2, which means that it experienced extensive alteration by water-rich fluids on its parent body before falling to Earth. CM chondrites, together with the CI group, are rich in carbon and are among the most chemically primitive meteorites. Like other CM chondrites, Murchison contains abundant calcium-aluminium-rich inclusions. More than 15 amino acids, some of the basic components of life, have been identified during multiple studies of this meteorite.
In January 2020, astronomers reported that Murchison meteorite silicon carbide particles had been determined to be 7 billion years old, 2.5 billion years older than the 4.54 billion years age of the Earth and the Solar System, and the oldest material found on Earth to date.
Organic compounds
Murchison contains common amino acids such as glycine, alanine, and glutamic acid as well as unusual ones such as isovaline and pseudoleucine. A complex mixture of alkanes was isolated as well, similar to that found in the Miller–Urey experiment. Serine and threonine, usually considered to be earthly contaminants, were conspicuously absent in the samples. A specific family of amino acids called diamino acids was identified in the Murchison meteorite as well.
The initial report stated that the amino acids were racemic and therefore formed in an abiotic manner, because amino acids of terrestrial proteins are all of the L-configuration of chirality. Later the amino acid alanine, which is also a protein amino acid, was found to have an excess of the L-configuration, which led several scientists to suspect terrestrial contamination according to the argument that it would be "unusual for an abiotic stereoselective decomposition or synthesis of amino acids to occur with protein amino acids but not with non-protein amino acids". In 1997, L-excesses also were found in a non-protein amino acid, isovaline, suggesting an extraterrestrial source for molecular asymmetry in the Solar System. At the same time, L-excesses of alanine were found in Murchison, but with enrichment in the isotope 15N, however, the isotopic pairing was contested later, on analytical grounds. By 2001, the list of organic materials identified in the meteorite was extended to polyols.
The meteorite contained a mixture of left-handed and right-handed amino acids; most amino acids used by living organisms are left-handed in chirality, and most sugars used are right-handed. A team of chemists in Sweden demonstrated in 2005 that this homochirality could have been triggered or catalyzed by the action of a left-handed amino acid such as proline.
Several lines of evidence indicate that the interior portions of well-preserved fragments from Murchison are pristine. A 2010 study using high resolution analytical tools including spectroscopy, identified 14,000 molecular compounds, including 70 amino acids, in a sample of the meteorite. The limited scope of the analysis by mass spectrometry provides for a potential 50,000 or more unique molecular compositions, with the team estimating the possibility of millions of distinct organic compounds in the meteorite.
Nucleobases
Measured purine and pyrimidine compounds were found in the Murchison meteorite. Carbon isotope ratios for uracil and xanthine of δ13C = +44.5‰ and +37.7‰, respectively, indicate a non-terrestrial origin for these compounds. This specimen demonstrates that many organic compounds could have been delivered by early Solar System bodies and may have played a key role in life's origin.
See also
Cosmochemistry
Glossary of meteoritics
Panspermia
Notes
References
External links
Meteorites found in Australia
Geology of Victoria (state)
1969 in science
Modern Earth impact events
September 1969 events in Australia
1960s in Victoria (state)
20th-century astronomical events
|
```c++
#include "gurka.h"
#include <gtest/gtest.h>
#if !defined(VALHALLA_SOURCE_DIR)
#define VALHALLA_SOURCE_DIR
#endif
using namespace valhalla;
const std::unordered_map<std::string, std::string> build_config{
{"mjolnir.admin", {VALHALLA_SOURCE_DIR "test/data/netherlands_admin.sqlite"}}};
const std::vector<std::string>& costing = {"auto", "taxi", "bus", "truck",
"bicycle", "motor_scooter", "motorcycle", "pedestrian"};
TEST(Standalone, Oneway) {
constexpr double gridsize_metres = 100;
const std::string ascii_map = R"(
A---B---C---D---E
| |
J---I---H---G---F
)";
const gurka::ways ways = {
{"AB", {{"highway", "unclassified"}}},
{"BC", {{"highway", "unclassified"}}},
{"CD", {{"highway", "unclassified"}}},
{"DE", {{"highway", "unclassified"}}},
{"EF", {{"highway", "unclassified"}}},
{"FG", {{"highway", "unclassified"}}},
{"DG",
{{"highway", "unclassified"},
{"oneway", "yes"},
{"oneway:bicycle", "yes"},
{"oneway:foot", "yes"}}},
{"GH", {{"highway", "unclassified"}}},
{"HI", {{"highway", "unclassified"}}},
{"IJ", {{"highway", "unclassified"}}},
};
const auto layout =
gurka::detail::map_to_coordinates(ascii_map, gridsize_metres, {5.1079374, 52.0887174});
auto map =
gurka::buildtiles(layout, ways, {}, {}, "test/data/gurka_oneway_unclassified", build_config);
for (auto& c : costing) {
auto result = gurka::do_action(valhalla::Options::route, map, {"A", "J"}, c);
gurka::assert::raw::expect_path(result, {"AB", "BC", "CD", "DG", "GH", "HI", "IJ"});
}
for (auto const& c : costing) {
auto result = gurka::do_action(valhalla::Options::route, map, {"J", "A"}, c);
gurka::assert::raw::expect_path(result, {"IJ", "HI", "GH", "FG", "EF", "DE", "CD", "BC", "AB"});
}
}
TEST(Standalone, OnewayFootway) {
constexpr double gridsize_metres = 10;
const std::string ascii_map = R"(
A---B---C---D---E
| |
J---I---H---G---F
)";
const gurka::ways ways = {
{"AB", {{"highway", "unclassified"}}},
{"BC", {{"highway", "unclassified"}}},
{"CD", {{"highway", "unclassified"}}},
{"DE", {{"highway", "unclassified"}}},
{"EF", {{"highway", "unclassified"}}},
{"FG", {{"highway", "unclassified"}}},
{"DG",
{{"highway", "footway"},
{"bicycle", "yes"},
{"oneway:bicycle", "yes"},
{"oneway:foot", "yes"}}},
{"GH", {{"highway", "unclassified"}}},
{"HI", {{"highway", "unclassified"}}},
{"IJ", {{"highway", "unclassified"}}},
};
const auto layout =
gurka::detail::map_to_coordinates(ascii_map, gridsize_metres, {5.1079374, 52.0887174});
auto map = gurka::buildtiles(layout, ways, {}, {}, "test/data/gurka_oneway_footway", build_config);
for (auto& c : costing) {
auto result = gurka::do_action(valhalla::Options::route, map, {"A", "J"}, c);
if (c == "pedestrian" || c == "bicycle")
gurka::assert::raw::expect_path(result, {"AB", "BC", "CD", "DG", "GH", "HI", "IJ"});
else
gurka::assert::raw::expect_path(result, {"AB", "BC", "CD", "DE", "EF", "FG", "GH", "HI", "IJ"});
}
for (auto const& c : costing) {
auto result = gurka::do_action(valhalla::Options::route, map, {"J", "A"}, c);
gurka::assert::raw::expect_path(result, {"IJ", "HI", "GH", "FG", "EF", "DE", "CD", "BC", "AB"});
}
}
TEST(Standalone, OnewayFootwayAllowBike) {
constexpr double gridsize_metres = 10;
const std::string ascii_map = R"(
A---B---C---D---E
| |
J---I---H---G---F
)";
const gurka::ways ways = {
{"AB", {{"highway", "unclassified"}}},
{"BC", {{"highway", "unclassified"}}},
{"CD", {{"highway", "unclassified"}}},
{"DE", {{"highway", "unclassified"}}},
{"EF",
{{"highway", "unclassified"},
{"oneway", "yes"},
{"bicycle", "no"}}}, // tend not to favor footways, so make the costing use it
{"FG", {{"highway", "unclassified"}}},
{"DG", {{"highway", "footway"}, {"bicycle", "yes"}, {"oneway", "yes"}}},
{"GH", {{"highway", "unclassified"}}},
{"HI", {{"highway", "unclassified"}}},
{"IJ", {{"highway", "unclassified"}}},
};
const auto layout =
gurka::detail::map_to_coordinates(ascii_map, gridsize_metres, {5.1079374, 52.0887174});
auto map =
gurka::buildtiles(layout, ways, {}, {}, "test/data/gurka_oneway_footway_bike", build_config);
for (auto& c : costing) {
auto result = gurka::do_action(valhalla::Options::route, map, {"A", "J"}, c);
if (c == "pedestrian" || c == "bicycle")
gurka::assert::raw::expect_path(result, {"AB", "BC", "CD", "DG", "GH", "HI", "IJ"});
else
gurka::assert::raw::expect_path(result, {"AB", "BC", "CD", "DE", "EF", "FG", "GH", "HI", "IJ"});
}
}
TEST(Standalone, OnewayFlipped) {
constexpr double gridsize_metres = 10;
const std::string ascii_map = R"(
A---B---C---D---E
| |
J---I---H---G---F
)";
const gurka::ways ways = {
{"AB", {{"highway", "unclassified"}}},
{"BC", {{"highway", "unclassified"}}},
{"CD", {{"highway", "unclassified"}}},
{"DE", {{"highway", "unclassified"}}},
{"EF", {{"highway", "unclassified"}}},
{"FG", {{"highway", "unclassified"}}},
{"DG",
{{"highway", "footway"}, {"bicycle", "yes"}, {"oneway:bicycle", "-1"}, {"oneway:foot", "-1"}}},
{"GH", {{"highway", "unclassified"}}},
{"HI", {{"highway", "unclassified"}}},
{"IJ", {{"highway", "unclassified"}}},
};
const auto layout =
gurka::detail::map_to_coordinates(ascii_map, gridsize_metres, {5.1079374, 52.0887174});
auto map = gurka::buildtiles(layout, ways, {}, {}, "test/data/gurka_oneway_flipped", build_config);
for (auto& c : costing) {
auto result = gurka::do_action(valhalla::Options::route, map, {"A", "J"}, c);
gurka::assert::raw::expect_path(result, {"AB", "BC", "CD", "DE", "EF", "FG", "GH", "HI", "IJ"});
}
}
```
|
Tony Aspromourgos (born 1957-01-11) is an Australian historian of economic thought, professor at the University of Sydney and a Fellow of the Academy of the Social Sciences in Australia (ASSA). He has published several books and many articles in economic journals on different subjects concerning the history of economic thought, especially on William Petty, Richard Cantillon and Adam Smith.
Biography
In 1978 Aspromourgos did his Bachelor of Economics at the University of Queensland. Three years later, in 1981 he became a Master of Commerce at the University of Melbourne, and in the same year he received his degree as a Master of Arts at the University of Chicago. In 1986, he obtained his Ph.D. at the University of Sydney.
Since 1978 Aspromourgos has held positions at the University of Melbourne and the University of Sydney:
1978-1980: Tutor in Economics (University of Melbourne)
1980: Senior Tutor in Economics (University of Melbourne)
1985-1989: Lecturer in Economics (University of Sydney)
1990-1997: Senior Lecturer in Economics (University of Sydney)
1998-2005: Associate Professor of Economics (University of Sydney)
since 2006: Professor of Economics (University of Sydney)
Work
Apart from his specialisation in the history of economic thought, Aspromourgos also specialised in monetary economics, macro-economics and long-period theory.
His research activities were concentrated on William Petty and the origins of classical economics, on Adam Smith, on John Maynard Keynes and on the question of public debt sustainability.
Aspromourgos published in many international economic journals, including Australian Economic Papers, Oxford Economic Papers, and the Review of Political Economy. He is co-editor of the History of Economics Review and serves on the editorial board of the European Journal of the History of Economic Thought.
Aspromourgos is Secretary of ESHET, the European Society for the History of Economic Thought.
Bibliography
Books
Journal articles
References
Historians of economic thought
20th-century Australian economists
21st-century Australian economists
Fellows of the Academy of the Social Sciences in Australia
Living people
Australian economics writers
1957 births
|
```scss
@import "../error-message/index";
@import "../hint/index";
@import "../label/index";
@include govuk-exports("govuk/component/input") {
.govuk-input {
@include govuk-font($size: 19);
box-sizing: border-box;
width: 100%;
height: govuk-px-to-rem(40px);
margin-top: 0;
padding: govuk-spacing(1);
// Setting any background-color makes text invisible when changing colours
// to dark backgrounds in Firefox (path_to_url As
// background-color and color need to always be set together, color should
// not be set either
border: $govuk-border-width-form-element solid $govuk-input-border-colour;
border-radius: 0;
// Disable inner shadow and remove rounded corners
appearance: none;
&:focus {
outline: $govuk-focus-width solid $govuk-focus-colour;
// Ensure outline appears outside of the element
outline-offset: 0;
// Double the border by adding its width again. Use `box-shadow` for this
// instead of changing `border-width` - this is for consistency with
// components such as textarea where we avoid changing `border-width` as
// it will change the element size. Also, `outline` cannot be utilised
// here as it is already used for the yellow focus state.
box-shadow: inset 0 0 0 $govuk-border-width-form-element;
}
&:disabled {
opacity: 0.5;
color: inherit;
background-color: transparent;
cursor: not-allowed;
}
}
.govuk-input::-webkit-outer-spin-button,
.govuk-input::-webkit-inner-spin-button {
margin: 0;
-webkit-appearance: none;
}
.govuk-input[type="number"] {
-moz-appearance: textfield;
}
.govuk-input--error {
border-color: $govuk-error-colour;
&:focus {
border-color: $govuk-input-border-colour;
}
}
.govuk-input--extra-letter-spacing {
@include govuk-font-tabular-numbers;
letter-spacing: 0.05em;
}
// em measurements are based on the point size of the typeface
// Extra space is added on the right to allow for the Safari prefill icon
.govuk-input--width-30 {
max-width: 29.5em;
}
.govuk-input--width-20 {
max-width: 20.5em;
}
.govuk-input--width-10 {
max-width: 11.5em;
}
.govuk-input--width-5 {
max-width: 5.5em;
}
.govuk-input--width-4 {
max-width: 4.5em;
}
.govuk-input--width-3 {
max-width: 3.75em;
}
.govuk-input--width-2 {
max-width: 2.75em;
}
.govuk-input__wrapper {
display: flex;
.govuk-input {
flex: 0 1 auto;
}
.govuk-input:focus {
// Hack to stop focus style being overlapped by the suffix
z-index: 1;
}
// Split prefix/suffix onto separate lines on narrow screens
@include govuk-media-query($until: mobile) {
display: block;
.govuk-input {
// Set max-width to override potential width override class on the input
max-width: 100%;
}
}
}
.govuk-input__prefix,
.govuk-input__suffix {
@include govuk-font($size: 19);
box-sizing: border-box;
// Use flexbox to align text within the prefix and suffix
display: flex;
align-items: center;
justify-content: center;
min-width: govuk-px-to-rem(40px);
height: govuk-px-to-rem(40px);
padding: govuk-spacing(1);
border: $govuk-border-width-form-element solid $govuk-input-border-colour;
background-color: govuk-colour("light-grey");
text-align: center;
white-space: nowrap;
// Emphasise non-editable status of prefixes and suffixes
cursor: default;
flex: 0 0 auto;
// Split prefix/suffix onto separate lines on narrow screens
@include govuk-media-query($until: mobile) {
display: block;
height: 100%;
white-space: normal;
}
}
.govuk-input__prefix {
@include govuk-media-query($until: mobile) {
border-bottom: 0;
}
@include govuk-media-query($from: mobile) {
border-right: 0;
}
}
// Split prefix/suffix onto separate lines on narrow screens
.govuk-input__suffix {
@include govuk-media-query($until: mobile) {
border-top: 0;
}
@include govuk-media-query($from: mobile) {
border-left: 0;
}
}
}
```
|
The Internet Party and Mana Movement, also stylised as Internet Party and MANA Movement or simply Internet MANA, was a coalition of the Internet Party and the Mana Movement formed to contest the party vote in the 2014 New Zealand general election.
History
In May 2014, Internet Party chief executive Vikram Kumar and Mana Movement leader Hone Harawira announced a merger of the parties, to be known as the Internet Party and Mana Movement, or the abbreviated Internet Mana. Harawira is the founding leader of the party. Mana member Sue Bradford resigned immediately after the merger was announced. The party and its logo were registered with the New Zealand Electoral Commission on 24 July 2014, allowing the party to contest the party vote.
The Internet Party and Mana Movement contested the 2014 general election as a single entity. The memorandum of understanding between the Mana Movement and Internet Party gave the Mana Movement first, third and fourth places on the combined party list, while the Internet Party took second, fifth and sixth places. Subsequent places on the party list alternate between the two component parties. Electorate candidates stood as members of their respective parties rather than Internet Party and Mana Movement. The memorandum of understanding states that the agreement would remain in force until at least six weeks after polling day. The two component parties agreed to review their arrangement within five weeks of the election.
The Internet Party and Mana Movement was funded by online millionaire Kim Dotcom. It failed to win a seat in parliament. Dotcom, who was not a candidate because he is not a New Zealand citizen, told reporters as election results became clear, "I take full responsibility for this loss tonight because the brand—the brand Kim Dotcom—was poison for what we were trying to achieve."
Following post-election reviews by both components of the Internet Mana Movement, the relationship was dissolved on 13 December with both sides agreeing there had been 'no regrets' about the decision made to run together.
Electoral results
References
Political parties in New Zealand
Political parties established in 2014
2014 establishments in New Zealand
Defunct political parties in New Zealand
2014 disestablishments in New Zealand
|
Amphibolite () is a metamorphic rock that contains amphibole, especially hornblende and actinolite, as well as plagioclase feldspar, but with little or no quartz. It is typically dark-colored and dense, with a weakly foliated or schistose (flaky) structure. The small flakes of black and white in the rock often give it a salt-and-pepper appearance.
Amphibolite frequently forms by metamorphism of mafic igneous rocks, such as basalt. However, because metamorphism creates minerals entirely based upon the chemistry of the protolith, certain 'dirty marls' and volcanic sediments may also metamorphose to an amphibolite assemblage. Deposits containing dolomite and siderite also readily yield amphibolite (tremolite-schist, grunerite-schist, and others) especially where there has been a certain amount of contact metamorphism by adjacent granitic masses. Metamorphosed basalt (metabasalt) creates ortho-amphibolite and other chemically appropriate lithologies create para-amphibolite.
Although tremolite is a metamorphic amphibole, it is most commonly derived from highly metamorphosed ultramafic rocks, and thus tremolite-talc schist is not generally considered a variety of amphibolite. A holocrystalline plutonic igneous rock composed primarily of hornblende amphibole is called a hornblendite, which is usually a crystal cumulate rock. Igneous rocks with greater than 90% amphiboles, which have a feldspar groundmass, may be lamprophyres.
Ortho-amphibolite vs. para-amphibolite
Metamorphic rocks composed primarily of amphibole, plagioclase, with subordinate epidote, zoisite, chlorite, quartz, titanite, and accessory leucoxene, ilmenite and magnetite which have a protolith of an igneous rock are known as ortho-amphibolite.
Para-amphibolite will generally have the same equilibrium mineral assemblage as ortho-amphibolite, with more biotite, and may include more quartz, plagioclase, and depending on the protolith, more calcite/aragonite and wollastonite.
Often the easiest way to determine the true nature of an amphibolite is to inspect its field relationships; especially whether it is interfingered with other metasedimentary rocks, especially greywacke and other poorly sorted sedimentary rocks. If the amphibolite appears to transgress apparent protolith bedding surfaces it is an ortho-amphibolite, as this suggests it was a dyke. Picking a sill and thin metamorphosed lava flows may be more troublesome.
Thereafter, whole rock geochemistry will suitably identify ortho- from para-amphibolite.
The word metabasalt was thus coined, largely to avoid the confusion between ortho-amphibolite and para-amphibolite. This term is recommended by the British Geological Survey when it is possible to determine the origin of the rock from its characteristics alone (and not from field relationships), particularly when the degree of metamorphism is low.
Amphibolite facies
Amphibolite as a rock defines a particular set of temperature and pressure conditions known as the amphibolite facies. However, caution must be applied here before embarking on metamorphic mapping based on amphibolite alone.
First, for an ortho-amphibolite or amphibolite to be classed as a metamorphic amphibolite, it must be certain that the amphibole in the rock is a prograde metamorphic product, and not a retrograde metamorphic product. For instance, actinolite amphibole is a common product of retrograde metamorphism of metabasalt at (upper) greenschist facies conditions. Often, this will take on the crystal form and habit of the original protolith assemblage; actinolite pseudomorphically replacing pyroxene is an indication that the amphibolite may not represent a peak metamorphic grade in the amphibolite facies.
Actinolite schist is often the result of hydrothermal alteration or metasomatism, and thus may not, necessarily, be a good indicator of metamorphic conditions when taken in isolation.
Second, the microstructure and crystal size of the rock must be appropriate. Amphibolite facies conditions are experienced at temperatures in excess of 500 °C and pressures less than 1.2 GPa, well within the ductile deformation field. Gneissic texture may occur nearby, if not then mylonite zones, foliations and ductile behaviour, including stretching lineations may occur.
While it is not impossible to have remnant protolith mineralogy, this is rare. More common is to find phenocrysts of pyroxene, olivine, plagioclase and even magmatic amphibole such as pargasite rhombohedra, pseudomorphed by hornblende amphibole. Original magmatic textures, especially crude magmatic layering in layered intrusions, is often preserved.
Amphibolite facies equilibrium mineral assemblages of various protolith rock types consist of:
Basalt ortho-amphibolite; hornblende/actinolite +/- albite +/- biotite +/- quartz +/- accessories; often remnant greenschist facies assemblages including, notably, chlorite
High-magnesia basalt; as ortho-amphibolite, but may contain anthophyllite, a Mg-rich amphibole
Ultramafic rocks; tremolite, asbestiform amphibole, talc, pyroxene, wollastonite, prograde metamorphic olivine (rarely)
Sedimentary para-amphibolite; hornblende/actinolite +/- albite +/- biotite +/- quartz +/- garnet (calcite +/- wollastonite)
Pelite; quartz, orthoclase +/- albite, +/- biotite +/- actinolite +/- garnet +/- staurolite +/- sillimanite
Amphibolite facies is usually a product of Barrovian Facies Sequence or advanced Abukuma Facies Sequence metamorphic trajectories. Amphibolite facies is a result of continuing burial and thermal heating after greenschist facies is exceeded. Further burial and metamorphic compression (but little extra heat) will lead to eclogite facies metamorphism; with more advanced heating the majority of rocks begin melting in excess of 650 to 700 °C in the presence of water. In dry rocks, however, additional heat (and burial) may result in granulite facies conditions.
Uralite
Uralite is a particular hydrothermally altered pyroxenite; during autogenic hydrothermal circulation the primary mineralogy of pyroxene and plagioclase, etc. has altered to actinolite and saussurite (albite + epidote). The texture is distinctive, the pyroxene altered to fuzzy, radially arranged actinolite pseudomorphically after pyroxene, and saussuritised plagioclase.
Epidiorite
The archaic term epidiorite is sometimes used, especially in Europe, to refer to a metamorphosed ortho-amphibolite with a protolith of diorite, gabbro or other mafic intrusive rock. In epidiorite the original clinopyroxene (most often augite) has been replaced by the fibrous amphibole uralite.
Uses
Amphibolite was a favourite material for the production of adzes (shoe-last-celts) in the central European early Neolithic (Linearbandkeramic and Rössen cultures).
Amphibolite is a common dimension stone used in construction, paving, facing of buildings, especially because of its attractive textures, dark color, hardness and polishability and its ready availability.
References
Winter, John D., 2001. An introduction to Igneous and Metamorphic Petrology, 695 pages, Prentice Hall,
Metamorphic petrology
Metamorphic rocks
|
Chandra Kumar Rasaili (), more popularly known as CK Rasaili(), is a Nepalese musician contemporary to Narayan Gopal and Gopal Yonjan.
Biography
Rasaili was born in Baluchistan region of Pakistan when his father was a soldier in the British Army. He has seven siblings.
He studied up to high school from Meghalaya, India. There he played for orchestra. In 2020BS, he and his team came to Nepal to celebrate the birthday of King Mahendra and performed at Rastriya Nach Ghar. King liked his performance. King Mahendra also gave him a song to compose a music. The song was later recorded in Calcutta. He worked in Radio Nepal. He also composed for Nepal police and Nepal army.
Awards
Narayan Gopal Memorial Award 2017
Natikaji National Music Award
References
Nepalese musicians
|
Teige Fitzpatrick, 4th Baron Upper Ossory (also known as Thady Fitzpatrick)(d. December 1627) was the son and heir of Florence Fitzpatrick, 3rd Baron Upper Ossory, by his wife Catherine O'More. He married Joan Butler, the daughter of Sir Edmund Butler of Cloughgrenan.
By her, he had issue:
Brian, aka Barnaby Fitzpatrick, 5th Baron Upper Ossory, his successor.
Dermot, aka Darby, who was twice married: firstly, Ellinor Comerford (daughter of Richard Comerford, Esq.), widow of John Kennedy, Esq.; and secondly, Ellen Shortall (daughter of Nicholas Shortall, Esq.). He and his son, Dermot Oge, were killed in a battle against English troops at Borris-in-Ossory in 1642.
Turlough, who married Onora Grace (daughter of Oliver Grace, Esq.).
John
Margaret, married to Thomas Hovenden of Tankardstown Castle, Queen's Co.
Catherine, married to Callaghan Fitzgerald of Cloghkyle, Queen's Co.
Onora
Joan, married to William Butler, Esq., of Lynon, Co. Tipperary.
Teige Fitzpatrick died in December 1627 and rests at Aghamacart. His Lady Joan died in late 1631. Her will indicates a granddaughter named "Uny ny Donel" ("Una daughter of Donnell"), thereby indicating that Teige may have had another son, Donnell, who was omitted from the pedigree. Alternately, this could be a granddaughter through one of their daughters.
Notes
External links
The Fitzpatrick – Mac Giolla Phádraig Clan Society
Teige
1627 deaths
Barons in the Peerage of Ireland
|
Romaine Jennifer Hart (14 June 1933 – 28 December 2021) was a British film executive. She opened a stylish cinema named The Screen on the Green in Islington. She ran a small film distribution company that ran a number of cinemas.
Life
Hart was born in Streatham in 1933, the only child of Goldie and Alex Bloom. Her father's family had been involved in the cinema business since the silent era. She left school in Brighton at sixteen and went to secretarial college, but was allowed to help organise the Royal Cinema in Deal. She inherited a financial interest in Bloom Theatres in 1968, after the death of her father.
Hart re-opened the The Screen on the Green cinema on 13 September 1970, in the "fleapit" Rex Cinema in Islington, which she had inherited. The Screen on the Green was comprehensively modernised in February 1981 by architects Fletcher Priest, who used chrome and glass to restyle the building. They created a foyer space, which reduced the cinema's capacity to 300 seats. The 1969 film, Downhill Racer, starring Robert Redford, was an inspired choice for the first film at the re-opened cinema, which Quentin Tarantino would call the "coolest cinema in London". The first-night audience included Richard Attenborough, Laurence Olivier and Brian Forbes. Her programmer was Roger Austin.
The cinema screened important films including Picnic at Hanging Rock, Monty Python’s Life of Brian, Nashville, Taxi Driver and Pink Flamingoes. Her cinemas ran all-night shows and costs were kept low. Stephen Woolley was one of her staff and remembered how staff would sell ice cream between double bills at one o'clock in the morning.
The Screen on the Green was joined by six other cinemas, mostly in London, including Screen on the Hill in Belsize Park, The Screen on Baker Street and The Screen Cinema in Winchester. The cinemas had different characters, the Screen on the Green was punk whereas the Screen on the Hill was known for its club for children that attracted celebrities including leading literati; Roald Dahl, Michael Palin and local executive Tom Maschler.
Hart solved her problem of getting films by starting her own film distribution company. She owned the rights in the UK to films including Maîtresse, The Fourth Man, This Is Spinal Tap, My Beautiful Laundrette, Pee-wee's Big Adventure and The Loveless.
She sat on the board of the National Film and Television School and the National Film Finance Corporation led by David Puttnam.
She was awarded the OBE in 1993.
In 2008, her cinema circuit was sold to the Everyman Media Group for £7m.
Romaine Hart died on 28 December 2021 at the age of 88.
References
1933 births
2021 deaths
People from Streatham
Film studio executives
|
Palmela is a Portuguese wine region centered on the town of Palmela in the Setúbal Peninsula subregion. The wine region has the Denominação de Origem Controlada (DOC) status after having been elevated from its former Indicação de Proveniencia Regulamentada (IPR) status. At the same time, the former Arrábida IPR, centered on the Arrabida hills, was absorbed into Palmela DOC.
Palmela first gained attention for its off dry white wines made from Muscat grapes harvested early but has recently turned its attention to producing dry red and white table wines. The soil of the area of the former Arrábida IPR is predominantly limestone with good drainage potential for the cultivation of red wine varieties.
Grapes
The principal grapes of the Palmela region (including the former Arrábida IPR) include Alfrocheiro, Arinto, Cabernet Sauvignon, Fernao Pires, Muscat of Alexandria, Periquita, Rabo de Ovelha, Roupeiro, Tamarez and Tinta Amarela.
See also
List of Portuguese wine regions
References
Wine regions of Portugal
|
Rashkan (, also Romanized as Rashkān and Rashakān; also known as Rīshakān) is a village in Dul Rural District, in the Central District of Urmia County, West Azerbaijan Province, Iran. At the 2006 census, its population was 434, in 132 families.
References
Populated places in Urmia County
|
```go
package server
import (
"context"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"net/url"
"strconv"
"strings"
"github.com/caicloud/nirvana/log"
c_v1alpha1 "github.com/caicloud/cyclone/pkg/apis/cyclone/v1alpha1"
"github.com/caicloud/cyclone/pkg/server/apis/v1alpha1"
"github.com/caicloud/cyclone/pkg/server/biz/scm"
"github.com/caicloud/cyclone/pkg/util/cerr"
)
const (
// SupportAccessTokenVersion represents the lowest version
// that support personal access token.
SupportAccessTokenVersion = "5.5.0"
// SupportPrModifiedEvent represents the lowest version
// that support event key named pr:modified.
SupportPrModifiedEvent = "5.10.0"
// SupportPrFromRefUpdatedEvent represents the lowest version
// that support pr:from_ref_updated event.
SupportPrFromRefUpdatedEvent = "7.0.0"
)
// Property represents BitBucket Server property.
type Property struct {
Version string `json:"version"`
}
// BitbucketServer represents the SCM provider of BitBucket Server.
type BitbucketServer struct {
scmCfg *v1alpha1.SCMSource
v1Client *V1Client
}
// NewBitbucketServer new a SCM provider of BitBucket Server.
func NewBitbucketServer(scmCfg *v1alpha1.SCMSource, v1Client *V1Client) *BitbucketServer {
return &BitbucketServer{
scmCfg: scmCfg,
v1Client: v1Client,
}
}
// GetToken gets the token by the username and password of SCM config.
func (b *BitbucketServer) GetToken() (string, error) {
if b.scmCfg.AuthType == v1alpha1.AuthTypePassword {
version, err := GetBitbucketVersion(b.v1Client.client, b.v1Client.baseURL)
if err != nil {
return "", err
}
isSupportToken, err := IsHigherVersion(version, SupportAccessTokenVersion)
if err != nil {
return "", err
}
if isSupportToken {
opt := PermissionReq{
Name: "continuous-integration/cyclone",
Permissions: []string{ProjectRead, RepoAdmin},
}
token, resp, err := b.v1Client.Authorizations.CreateAccessToken(context.Background(), b.scmCfg.User, opt)
if err != nil {
return "", convertBitBucketError(err, resp)
}
return token, nil
}
return b.scmCfg.Password, nil
}
return b.scmCfg.Token, nil
}
// CheckToken checks whether the token has the authority of repo by trying ListRepos with the token.
func (b *BitbucketServer) CheckToken() error {
repos, err := b.listReposInner(false)
if err != nil {
return err
}
if len(repos) == 0 {
return cerr.ErrorExternalAuthorizationFailed.Error(fmt.Errorf("No repositories found"))
}
return nil
}
// ListRepos lists the repos by the SCM config.
func (b *BitbucketServer) ListRepos() ([]scm.Repository, error) {
return b.listReposInner(true)
}
// listReposInner lists the projects by the SCM config,
// list all projects while the parameter 'listAll' is true,
// otherwise, list projects by default 'ListPerPageOpt' number.
func (b *BitbucketServer) listReposInner(listAll bool) ([]scm.Repository, error) {
opt := ListOpts{}
var allRepos []Repository
for {
repos, resp, err := b.v1Client.Repositories.ListRepositories(context.Background(), "", &opt)
if err != nil {
return nil, convertBitBucketError(err, resp)
}
allRepos = append(allRepos, repos.Values...)
if repos.NextPage == nil || !listAll {
break
}
opt.Start = repos.NextPage
}
scmRepos := make([]scm.Repository, len(allRepos))
for i, repo := range allRepos {
scmRepos[i].Name = fmt.Sprintf("%s/%s", repo.Project.Key, repo.Slug)
for _, clone := range repo.Links.Clone {
if clone.Name == "http" || clone.Name == "https" {
scmRepos[i].URL = clone.Href
break
}
}
}
return scmRepos, nil
}
// ListBranches lists the branches for specified repo.
func (b *BitbucketServer) ListBranches(repo string) ([]string, error) {
var projectKey string
var err error
if projectKey, repo, err = parseRepo(b.scmCfg, repo); err != nil {
log.Error(err)
return nil, err
}
opt := ListOpts{}
var allBranches []Branch
for {
branches, resp, err := b.v1Client.Repositories.ListBranches(context.Background(), projectKey, repo, &opt)
if err != nil {
log.Errorf("Fail to list branches for %s as %v", repo, err)
return nil, convertBitBucketError(err, resp)
}
allBranches = append(allBranches, branches.Values...)
if branches.NextPage == nil {
break
}
opt.Start = branches.NextPage
}
branchNames := make([]string, len(allBranches))
for i, branch := range allBranches {
branchNames[i] = branch.DisplayID
}
return branchNames, nil
}
// ListTags lists the tags for specified repo.
func (b *BitbucketServer) ListTags(repo string) ([]string, error) {
var projectKey string
var err error
if projectKey, repo, err = parseRepo(b.scmCfg, repo); err != nil {
log.Error(err)
return nil, err
}
var allTags []Tag
opt := ListOpts{}
for {
tags, resp, err := b.v1Client.Repositories.ListTags(context.Background(), projectKey, repo, &opt)
if err != nil {
log.Errorf("Fail to list tags for %s as %v", repo, err)
return nil, convertBitBucketError(err, resp)
}
allTags = append(allTags, tags.Values...)
if tags.NextPage == nil {
break
}
opt.Start = tags.NextPage
}
tagNames := make([]string, len(allTags))
for i, tag := range allTags {
tagNames[i] = tag.DisplayID
}
return tagNames, nil
}
// ListPullRequests lists the pull requests for specified repo.
func (b *BitbucketServer) ListPullRequests(repo, state string) ([]scm.PullRequest, error) {
// Bitbucket pr state: OPEN, DECLINED, MERGED, ALL
var s string
switch state {
case "open":
s = "OPEN"
case "all":
s = "ALL"
case "OPEN", "DECLINED", "MERGED", "ALL":
s = state
default:
return nil, cerr.ErrorUnsupported.Error("Bitbucket pull request state", state)
}
var projectKey string
var err error
if projectKey, repo, err = parseRepo(b.scmCfg, repo); err != nil {
log.Error(err)
return nil, err
}
var allPRs []scm.PullRequest
opt := PullRequestListOpts{
State: s,
}
for {
prs, resp, err := b.v1Client.Repositories.ListPullRequests(context.Background(), projectKey, repo, &opt)
if err != nil {
log.Errorf("Fail to list pull requests for %s as %v", repo, err)
return nil, convertBitBucketError(err, resp)
}
allPRs = append(allPRs, prs.Values...)
if prs.NextPage == nil {
break
}
opt.Start = prs.NextPage
}
return allPRs, nil
}
// ListDockerfiles lists the Dockerfiles for specified repo.
func (b *BitbucketServer) ListDockerfiles(repo string) ([]string, error) {
var projectKey string
var err error
if projectKey, repo, err = parseRepo(b.scmCfg, repo); err != nil {
log.Error(err)
return nil, err
}
var allFiles []string
opt := ListOpts{}
for {
files, resp, err := b.v1Client.Repositories.ListFiles(context.Background(), projectKey, repo, &opt)
if err != nil {
log.Errorf("Fail to list files for %s as %s", repo, err)
return nil, convertBitBucketError(err, resp)
}
allFiles = append(allFiles, files.Values...)
if files.NextPage == nil {
break
}
opt.Start = files.NextPage
}
var dockerfiles []string
for _, file := range allFiles {
if scm.IsDockerfile(file) {
dockerfiles = append(dockerfiles, file)
}
}
return dockerfiles, nil
}
// CreateStatus generate a new status for repository.
func (b *BitbucketServer) CreateStatus(status c_v1alpha1.StatusPhase, targetURL, repoURL, commitSha string) error {
// BitBucket Server: SUCCESSFUL, FAILED and INPROGRESS.
state := ""
description := ""
switch status {
case c_v1alpha1.StatusRunning:
state = "INPROGRESS"
description = "Cyclone CI is in progress."
case c_v1alpha1.StatusSucceeded:
state = "SUCCESSFUL"
description = "Cyclone CI passed."
case c_v1alpha1.StatusFailed:
state = "FAILED"
description = "Cyclone CI failed."
case c_v1alpha1.StatusCancelled:
state = "FAILED"
description = "Cyclone CI failed."
default:
err := fmt.Errorf("not supported state:%s", status)
log.Error(err)
return err
}
label := "continuous-integration/cyclone"
opt := &StatusReq{
State: state,
Key: label,
Name: label,
URL: targetURL,
Description: description,
}
resp, err := b.v1Client.Repositories.CreateStatus(context.Background(), commitSha, opt)
return convertBitBucketError(err, resp)
}
// GetPullRequestSHA gets latest commit SHA of pull request.
func (b *BitbucketServer) GetPullRequestSHA(repoURL string, number int) (string, error) {
projectKey, name := scm.ParseRepo(repoURL)
pr, resp, err := b.v1Client.PullRequests.GetPullRequest(context.Background(), projectKey, name, number)
if err != nil {
log.Error(err)
return "", convertBitBucketError(err, resp)
}
return pr.FromRef.LatestCommit, nil
}
// CreateWebhook creates webhook for specified repo.
func (b *BitbucketServer) CreateWebhook(repo string, webhook *scm.Webhook) error {
if webhook == nil || len(webhook.URL) == 0 || len(webhook.Events) == 0 {
return fmt.Errorf("The webhook %v is not correct", webhook)
}
_, err := b.GetWebhook(repo, webhook.URL)
if err != nil {
if !cerr.ErrorContentNotFound.Derived(err) {
return err
}
webhookReq := Webhook{
URL: webhook.URL,
Events: make([]string, 0),
Active: true,
Name: "continuous-integration/cyclone",
}
for _, e := range webhook.Events {
switch e {
case scm.PullRequestEventType:
webhookReq.Events = append(webhookReq.Events, PrOpened)
version, err := GetBitbucketVersion(b.v1Client.client, b.v1Client.baseURL)
if err != nil {
return err
}
isSupportPrFromRefUpdated, err := IsHigherVersion(version, SupportPrFromRefUpdatedEvent)
if err != nil {
return err
}
if isSupportPrFromRefUpdated {
webhookReq.Events = append(webhookReq.Events, PrFromRefUpdated)
}
isSupportPrModified, err := IsHigherVersion(version, SupportPrModifiedEvent)
if err != nil {
return err
}
if isSupportPrModified {
webhookReq.Events = append(webhookReq.Events, PrModified)
}
case scm.PullRequestCommentEventType:
webhookReq.Events = append(webhookReq.Events, PrCommentAdded)
case scm.PushEventType, scm.TagReleaseEventType:
flag := false
for _, event := range webhookReq.Events {
if event == RefsChanged {
flag = true
break
}
}
if !flag {
webhookReq.Events = append(webhookReq.Events, RefsChanged)
}
default:
log.Errorf("The event type %s is not supported, will be ignored", e)
}
}
project, name := scm.ParseRepo(repo)
_, resp, err := b.v1Client.Repositories.CreateWebhook(context.Background(), project, name, webhookReq)
if err != nil {
log.Errorf("Create Webhook error: %v", err)
}
return convertBitBucketError(err, resp)
}
log.Warningf("Webhook already existed: %+v", webhook)
return nil
}
// DeleteWebhook deletes webhook from specified repo.
func (b *BitbucketServer) DeleteWebhook(repo string, webhookURL string) error {
project, name := scm.ParseRepo(repo)
webhook, err := b.GetWebhook(repo, webhookURL)
if err != nil {
return err
}
if resp, err := b.v1Client.Repositories.DeleteWebhook(context.Background(), project, name, webhook.ID); err != nil {
log.Errorf("delete project hook %s for %s/%s error: %v", webhook.ID, project, name, err)
return convertBitBucketError(err, resp)
}
return nil
}
// GetWebhook gets webhook from specified repo.
func (b *BitbucketServer) GetWebhook(repo string, webhookURL string) (*Webhook, error) {
project, name := scm.ParseRepo(repo)
opt := ListOpts{}
var allWebhooks []Webhook
for {
hooks, resp, err := b.v1Client.Repositories.ListWebhook(context.Background(), project, name)
if err != nil {
return nil, convertBitBucketError(err, resp)
}
allWebhooks = append(allWebhooks, hooks.Values...)
if hooks.NextPage == nil {
break
}
opt.Start = hooks.NextPage
}
for _, hook := range allWebhooks {
if strings.HasPrefix(hook.URL, webhookURL) {
return &hook, nil
}
}
return nil, cerr.ErrorContentNotFound.Error(fmt.Sprintf("webhook url %s", webhookURL))
}
func parseRepo(scmCfg *v1alpha1.SCMSource, repo string) (string, string, error) {
projectKey := fmt.Sprintf("~%s", scmCfg.User)
if strings.Contains(repo, "/") {
parts := strings.Split(repo, "/")
if len(parts) != 2 {
err := fmt.Errorf("invalid repo %s, must in format of '{projectKey}/{repo}'", repo)
return projectKey, repo, err
}
projectKey, repo = parts[0], parts[1]
}
return projectKey, repo, nil
}
// GetBitbucketVersion returns the version of the BitBucket Server
func GetBitbucketVersion(client *http.Client, base *url.URL) (string, error) {
resp, err := client.Get(fmt.Sprintf("%s%s", base.String(), "rest/api/1.0/application-properties"))
if err != nil {
return "", err
}
defer func() {
if err := resp.Body.Close(); err != nil {
log.Errorf("Fail to close response body as: %v", err)
}
}()
var property Property
if resp.StatusCode/100 == 2 {
err = json.NewDecoder(resp.Body).Decode(&property)
if err != nil {
return "", err
}
return property.Version, nil
}
bodyBytes, _ := ioutil.ReadAll(resp.Body)
return "", fmt.Errorf("status: %v, Body: %s", resp.Status, string(bodyBytes))
}
// IsHigherVersion compare the version with refVersion.
// If the version is lower than the refVersion, it will return false.
func IsHigherVersion(version string, refVersion string) (bool, error) {
parts := strings.Split(version, ".")
refParts := strings.Split(refVersion, ".")
if len(refParts) != 3 {
return false, fmt.Errorf("invalid refVersion: %s, it must be x.x.x", refVersion)
}
if len(parts) > 3 || len(parts) < 2 {
return false, fmt.Errorf("invalid version: %s", version)
}
if len(parts) == 2 {
parts = append(parts, "0")
}
for i, part := range parts {
partNumber, err := strconv.Atoi(part)
if err != nil {
return false, fmt.Errorf("invalid version: %s, error: %v", version, err)
}
refPartNumber, err := strconv.Atoi(refParts[i])
if err != nil {
return false, fmt.Errorf("invalid refVersion: %s, error: %v", refVersion, err)
}
if refPartNumber > partNumber {
return false, nil
} else if refPartNumber < partNumber {
return true, nil
}
}
return true, nil
}
func convertBitBucketError(err error, resp *http.Response) error {
if err == nil {
return nil
}
if resp != nil && resp.StatusCode == http.StatusInternalServerError {
return cerr.ErrorExternalSystemError.Error("BitBucket", err)
}
if resp != nil && resp.StatusCode == http.StatusUnauthorized {
return cerr.ErrorExternalAuthorizationFailed.Error(err)
}
if resp != nil && resp.StatusCode == http.StatusForbidden {
return cerr.ErrorExternalAuthenticationFailed.Error(err)
}
return cerr.AutoAnalyse(err)
}
```
|
```objective-c
/*
*
* path_to_url for terms and conditions.
*/
#ifndef LIQUIDCORE_COMMON_H
#define LIQUIDCORE_COMMON_H
#include "Common/JSValue.h"
#include "Common/Macros.h"
#endif //LIQUIDCORE_COMMON_H
```
|
```html+erb
<% add_decidim_page_title(t("info", scope: "decidim.admin.menu.initiatives_submenu")) %>
<% add_decidim_page_title(translated_attribute(current_participatory_space.title)) %>
<div class="item_show__header">
<h1 class="item_show__header-title">
<%= t("info", scope: "decidim.admin.menu.initiatives_submenu") %>
</h1>
</div>
<div class="item__edit item__edit-1col">
<div class="item__edit-form">
<%= decidim_form_for @form, html: { class: "form-defaults form edit_initiative" } do |f| %>
<%= render partial: "form", object: f %>
<div class="item__edit-sticky">
<div class="item__edit-sticky-container">
<%= f.submit t(".update"), class: "button button__sm button__secondary" if allowed_to? :update, :initiative, initiative: current_initiative %>
<% if allowed_to? :send_to_technical_validation, :initiative, initiative: current_initiative %>
<%= link_to t(".send_to_technical_validation"),
send_to_technical_validation_initiative_path(current_initiative),
class: "button button__sm button__secondary",
data: { confirm: t(".confirm_send_to_technical_validation") } %>
<% elsif current_initiative.created? %>
<%= link_to t(".send_to_technical_validation"), "#", class: "button button__sm button__secondary" %>
<% end %>
<% if allowed_to? :publish, :initiative, initiative: current_initiative %>
<%= link_to t("actions.publish", scope: "decidim.admin"),
publish_initiative_path(current_initiative),
method: :post,
class: "button button__sm button__secondary",
data: { confirm: t(".confirm") } %>
<% end %>
<% if allowed_to? :unpublish, :initiative, initiative: current_initiative %>
<%= link_to t("actions.unpublish", scope: "decidim.admin"),
unpublish_initiative_path(current_initiative),
method: :delete,
class: "button button__sm button__secondary",
data: { confirm: t(".confirm") } %>
<% end %>
<% if allowed_to? :accept, :initiative, initiative: current_initiative %>
<%= link_to t(".accept"),
accept_initiative_path(current_initiative),
method: :post,
class: "button button__sm button__secondary",
data: { confirm: t(".confirm") } %>
<% end %>
<% if allowed_to? :reject, :initiative, initiative: current_initiative %>
<%= link_to t(".reject"),
reject_initiative_path(current_initiative),
method: :delete,
class: "button button__sm button__secondary",
data: { confirm: t(".confirm") } %>
<% end %>
<% if allowed_to? :discard, :initiative, initiative: current_initiative %>
<%= link_to t(".discard"),
discard_initiative_path(current_initiative),
method: :delete,
class: "button button__sm button__secondary",
data: { confirm: t(".confirm") } %>
<% end %>
<% if allowed_to? :export_votes, :initiative, initiative: current_initiative %>
<%= link_to t(".export_votes"),
export_votes_initiative_path(current_initiative, format: :csv),
class: "button button__sm button__secondary",
data: { confirm: t(".confirm") } %>
<% end %>
<% if allowed_to? :export_pdf_signatures, :initiative, initiative: current_initiative %>
<%= link_to t(".export_pdf_signatures"),
export_pdf_signatures_initiative_path(current_initiative, format: :pdf),
class: "button button__sm button__secondary",
data: { confirm: t(".confirm") } %>
<% end %>
</div>
</div>
<% end %>
</div>
</div>
```
|
The Merauke Five are five Australian citizens who were detained by Indonesian authorities in the Papuan town of Merauke in 2008 for entering Indonesian territory without visas. The passengers were assured by the operator of the aircraft that visas were arranged and would be obtained upon arrival. Even without visas or security clearance, they were cleared to land by air traffic controllers, who were aware of their situation and assured them that a fine would be sufficient to clear the matter up. However, they were put in detention, then sentenced to jail.
The Merauke Five consisted of middle-aged Queenslanders – pilot William Scott-Bloxam, his wife Vera and passengers Keith Mortimer, Hubert Hofer and Karen Burke. The trip's intended purpose was part sightseeing and part business. Their arrival date was 12 September 2008.
Appeal
After being sentenced to between two and three years' jail each, the group appealed the case in the Jayapura High Court, resulting in their freedom as the court overturned the jail sentence. When they arrived at the airport, however, they found their plane surrounded by Indonesian security, who had confiscated it on behalf of the prosecutors who lodged an appeal to overturn the High Court ruling. The plane, they said, was required for evidence. And as the court ruling stipulated they must leave in their own plane, the Merauke Five were trapped at Mopah airport — too afraid to leave in case they would be charged again for other charges.
Defence lawyer Mohammad Rifan told Australian Associated Press that under Indonesian law, the prosecutors were not permitted to appeal against a High Court decision. "Under the law of the Criminal Code, 'article 244', if the court orders the release as soon as possible, right now, you cannot appeal to the Supreme Court," he said. "If this happened for an Indonesian national, they would be free straight away. Why not for an Australian national?"
But an Indonesian law expert in Australia said that while it is true the country does not allow appeal of absolute acquittals, they do allow it in other cases – such as, for example, if someone is acquitted because they were found to be under duress. "The question is whether the Merauke Five's is an absolute acquittal for the purposes of Indonesian law", said Director of the Asian Law Centre at Melbourne University, Professor Tim Lindsey. "That will be a first issue that will be raised when the issue comes back before the courts."
Lindsey noted, however, that Indonesian courts have been "quite inconsistent in how they interpret article '244', and have tended to read it in a way that will allow the appeal to go ahead". He also said that in Australia, it is unusual for a prosecutor to appeal.
Australian Government's response
Minister for Foreign Affairs, Stephen Smith, indicated that at that point, he would not put pressure on the Indonesian Government to release the five. "We have to go through and respect the Indonesian legal processes, and currently they are subject to an appeal to the Indonesian Supreme Court," he said. "Their status now is what is described as 'city detention'. So they effectively have what is described as a licence to the city, but we are giving them consular assistance."
Karen Burke, one of the five, pleaded with the Australian Government to do more to help. "We're scared to death to leave," she said. "We think if we put a foot out the front door we could be arrested on some other charges. Our position is quite precarious."
A Foreign Affairs spokesman in Australia said, "This situation is distressing for the Australians and their families, and the embassy in Jakarta is discussing with the five Australians and their lawyers the next steps towards obtaining their release and return. We understand that the five are no longer in detention, but are unable to depart for Australia. They are currently at the Immigration Office at Merauke Airport endeavouring to clarify their legal status. Our embassy consular official is also assisting them in consultation with the Indonesian authorities."
Difficulties in returning to Australia
Their convictions were dismissed by Indonesia's Supreme Court on 10 June 2009 and they were ordered to return to Australia. But 12 days later, on 22 June 20, the group was still waiting for Indonesia's attorney-general's office to issue a final piece of paperwork. "As soon as it has been issued it will take only a short time for the immigration department to issue the final release order," said the group's lawyer, Mohammad Rifan.
But some people within the attorney-general's office still seemed "reluctant" to let the Australians leave, Rifan said.
On Wednesday, Merauke District Court officials received from Jakarta the paperwork that enabled them to return the five Australians' passports and let the pilot, William Scott-Bloxam, fire up his twin-engined aircraft. However, the group's lawyer, Mohammad Rifan, said he feared prosecutors may yet raise further hurdles. "They still have not lifted the ban that prevents them leaving. They say they have to ask the attorney-general's office for guidance to do this," said Rifan. "But it seems like there is an effort from prosecutors to hinder the process."
Rifan was right. As immigration officials strode towards the Australians' light plane to hand over their stamped passports, an aggrieved prosecutor, Yafeth Bonai, emerged on the tarmac and intervened. With local media present and the bemused Australians watching, Mr Bonai started shouting at the immigration officials, saying he had not seen the paperwork that cleared the Australians to leave. A heated argument lasting 20 minutes took place in front of the plane, with Mr Bonai not prepared to accept assurances by the Indonesian immigration department that a travel ban had been lifted after the country's highest court found the Australians innocent of immigration and aviation offences. "I need to see it in black and white," Mr Bonai shouted. Told to phone his superiors and check, he responded, "We can't phone our bosses and order them around."
The officials agreed to leave and reconvene at Mr Bonai's office. After phone calls were made to Jakarta, Mr Bonai finally conceded the travel ban had been rescinded.
Safe arrival home
After their safe arrival home in late June 2009, the five, in front of news reporters, thanked all those who had a hand in their release, including the Australian Government. They avoided questions about the amount of help that had been provided by the Australian Government. When asked, Mr Mortimer replied with, "We have no complaints, they did a great job for us. I think they should have got themselves involved a lot earlier than they did but bottom line is they got there and we're out." They also made sure that they did not dump too heavily on the Indonesian authorities although they had strong suspicions that the case was driven by political motivation. "I don't know what was driving the Attorney-General's office, but it was certainly more than the fact that people didn't have visas or that the paperwork was not correct," Mr Scott-Bloxam said. "It's hard to imagine that you end up in the highest court in the land for a misdemeanour case," Mr Mortimer said.
Foreign Minister Stephen Smith was unavailable for an interview but the Department of Foreign Affairs issued an extensive statement welcoming the group home, but pointed out that before travelling, Australians needed to inform themselves about the laws of the countries they planned to visit. The statement also said that if people disobeyed foreign laws and ended up in court, the Government's ability to assist them would be very limited. The statement then stated that the Australian Government registered its strong interest in the case being handled expeditiously with the Indonesian Government.
After the Australians touched down in Horn Island, one of the five went back to work. Another worked on restoring his home – a boat on which he lived – to full order, and another took a break, too emotionally exhausted to think about working. William Scott-Bloxam, the main player in the five's detention, and wife Vera set about resurrecting their aviation business.
References
Prisoners and detainees of Indonesia
Living people
Australian people imprisoned abroad
Australia–Indonesia relations
Quantified groups of defendants
Trials in Indonesia
Year of birth missing (living people)
|
James Spencer Braude (born May 7, 1949) is a lawyer, former union official, and Boston radio and television personality.
Early life and education
Braude, an only child, was born in Philadelphia, Pennsylvania in 1949 and raised in the Center City area.
He graduated from Central High School in Philadelphia in 1966. He went to the University of Pennsylvania for his bachelor's degree and to New York University School of Law for his Juris Doctor degree.
Personal life
Braude has two children adopted from China.
Legal career
He began his legal career as a legal services lawyer in the South Bronx neighborhood of New York City with housing and prisoner's rights cases. He was the founder and first president of the National Organization of Legal Services Workers (NOLSW), a UAW affiliated union which represented staff in civil legal offices for the poor in various states.
He subsequently served as the executive director of the Tax Equity Alliance for Massachusetts (TEAM), a tax reform coalition. He published the magazine Otherwise, on American politics.
Braude later served as a Cambridge, Massachusetts City Councilor.
Broadcast journalism career
He co-hosts, with Margery Eagan of Boston Public Radio, a midday talk show on WGBH radio that airs on weekdays. The pair formerly hosted the Jim & Margery Show talk show on WTKK, before that station became a music station in January 2013.
He also hosted Broadside with Jim Braude on New England Cable News (NECN). In mid-January 2015, he announced his departure from NECN.
On January 22, 2015, he was named as the executive editor and host of WGBH News local television news and analysis program, Greater Boston, replacing long-time host Emily Rooney. He departed the program on December 15, 2022.
Awards
Braude won a local Emmy award and an Associated Press award for his work on NECN.
References
1949 births
Living people
American talk radio hosts
Television anchors from Boston
University of Pennsylvania alumni
New York University School of Law alumni
Radio personalities from Boston
Central High School (Philadelphia) alumni
|
```smalltalk
using Ocelot.Configuration.File;
using Ocelot.LoadBalancer.LoadBalancers;
namespace Ocelot.Configuration.Creator;
public class RouteKeyCreator : IRouteKeyCreator
{
/// <summary>
/// Creates the unique <see langword="string"/> key based on the route properties for load balancing etc.
/// </summary>
/// <remarks>
/// Key template:
/// <list type="bullet">
/// <item>UpstreamHttpMethod|UpstreamPathTemplate|UpstreamHost|DownstreamHostAndPorts|ServiceNamespace|ServiceName|LoadBalancerType|LoadBalancerKey</item>
/// </list>
/// </remarks>
/// <param name="fileRoute">The route object.</param>
/// <returns>A <see langword="string"/> object containing the key.</returns>
public string Create(FileRoute fileRoute)
{
var isStickySession = fileRoute.LoadBalancerOptions is
{
Type: nameof(CookieStickySessions),
Key.Length: > 0
};
if (isStickySession)
{
return $"{nameof(CookieStickySessions)}:{fileRoute.LoadBalancerOptions.Key}";
}
var upstreamHttpMethods = Csv(fileRoute.UpstreamHttpMethod);
var downstreamHostAndPorts = Csv(fileRoute.DownstreamHostAndPorts.Select(downstream => $"{downstream.Host}:{downstream.Port}"));
var keyBuilder = new StringBuilder()
// UpstreamHttpMethod and UpstreamPathTemplate are required
.AppendNext(upstreamHttpMethods)
.AppendNext(fileRoute.UpstreamPathTemplate)
// Other properties are optional, replace undefined values with defaults to aid debugging
.AppendNext(Coalesce(fileRoute.UpstreamHost, "no-host"))
.AppendNext(Coalesce(downstreamHostAndPorts, "no-host-and-port"))
.AppendNext(Coalesce(fileRoute.ServiceNamespace, "no-svc-ns"))
.AppendNext(Coalesce(fileRoute.ServiceName, "no-svc-name"))
.AppendNext(Coalesce(fileRoute.LoadBalancerOptions.Type, "no-lb-type"))
.AppendNext(Coalesce(fileRoute.LoadBalancerOptions.Key, "no-lb-key"));
return keyBuilder.ToString();
}
/// <summary>
/// Helper function to convert multiple strings into a comma-separated string.
/// </summary>
/// <param name="values">The collection of strings to join by comma separator.</param>
/// <returns>A <see langword="string"/> in the comma-separated format.</returns>
private static string Csv(IEnumerable<string> values) => string.Join(',', values);
/// <summary>
/// Helper function to return the first non-null-or-whitespace string.
/// </summary>
/// <param name="first">The 1st string to check.</param>
/// <param name="second">The 2nd string to check.</param>
/// <returns>A <see langword="string"/> which is not empty.</returns>
private static string Coalesce(string first, string second) => string.IsNullOrWhiteSpace(first) ? second : first;
}
internal static class RouteKeyCreatorHelpers
{
/// <summary>
/// Helper function to append a string to the key builder, separated by a pipe.
/// </summary>
/// <param name="builder">The builder of the key.</param>
/// <param name="next">The next word to add.</param>
/// <returns>The reference to the builder.</returns>
public static StringBuilder AppendNext(this StringBuilder builder, string next)
{
if (builder.Length > 0)
{
builder.Append('|');
}
return builder.Append(next);
}
}
```
|
```javascript
/**
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
'use strict';
// MODULES //
var tape = require( 'tape' );
var uniform = require( '@stdlib/random/iter/uniform' );
var ahavercos = require( '@stdlib/math/base/special/ahavercos' );
var linspace = require( '@stdlib/iter/linspace' );
var array2iterator = require( '@stdlib/array/to-iterator' );
var iterAhavercos = require( './../lib' );
// TESTS //
tape( 'main export is a function', function test( t ) {
t.ok( true, __filename );
t.strictEqual( typeof iterAhavercos, 'function', 'main export is a function' );
t.end();
});
tape( 'the function throws an error if provided an iterator argument which is not an iterator protocol-compliant object', function test( t ) {
var values;
var i;
values = [
'5',
5,
NaN,
true,
false,
null,
void 0,
{},
[],
function noop() {}
];
for ( i = 0; i < values.length; i++ ) {
t.throws( badValue( values[i] ), TypeError, 'throws an error when provided '+values[i] );
}
t.end();
function badValue( value ) {
return function badValue() {
iterAhavercos( value );
};
}
});
tape( 'the function returns an iterator protocol-compliant object', function test( t ) {
var it;
var r;
var i;
it = iterAhavercos( uniform( 0.0, 1.0 ) );
t.equal( it.next.length, 0, 'has zero arity' );
for ( i = 0; i < 100; i++ ) {
r = it.next();
t.equal( typeof r.value, 'number', 'returns a number' );
t.equal( typeof r.done, 'boolean', 'returns a boolean' );
}
t.end();
});
tape( 'the function returns an iterator protocol-compliant object which computes the inverse half-value versed cosine of each iterated value', function test( t ) {
var expected;
var it;
var N;
var x;
var r;
var i;
N = 101;
it = iterAhavercos( linspace( 0.0, 1.0, N ) );
t.equal( it.next.length, 0, 'has zero arity' );
x = linspace( 0.0, 1.0, N );
for ( i = 0; i < N; i++ ) {
r = it.next();
expected = ahavercos( x.next().value );
t.equal( r.value, expected, 'returns expected value' );
t.equal( typeof r.done, 'boolean', 'returns a boolean' );
}
r = it.next();
t.equal( r.value, void 0, 'returns expected value' );
t.equal( r.done, true, 'returns expected value' );
t.end();
});
tape( 'the function returns an iterator protocol-compliant object which returns `NaN` if provided a non-numeric value', function test( t ) {
var expected;
var values;
var actual;
var it;
var r;
var i;
values = [ 'abc', null, true, false, [], {} ];
expected = [
{
'value': NaN,
'done': false
},
{
'value': NaN,
'done': false
},
{
'value': NaN,
'done': false
},
{
'value': NaN,
'done': false
},
{
'value': NaN,
'done': false
},
{
'value': NaN,
'done': false
},
{
'done': true
}
];
it = iterAhavercos( array2iterator( values ) );
t.equal( it.next.length, 0, 'has zero arity' );
for ( i = 0; i < expected.length; i++ ) {
actual = it.next();
r = expected[ i ].value;
if ( r === r ) {
t.equal( actual.value, r, 'returns expected value' );
} else {
t.notEqual( actual.value, actual.value, 'returns expected value' );
}
t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
}
t.end();
});
tape( 'the returned iterator has a `return` method for closing an iterator (no argument)', function test( t ) {
var it;
var r;
it = iterAhavercos( uniform( 0.0, 1.0 ) );
r = it.next();
t.equal( typeof r.value, 'number', 'returns a number' );
t.equal( r.done, false, 'returns expected value' );
r = it.next();
t.equal( typeof r.value, 'number', 'returns a number' );
t.equal( r.done, false, 'returns expected value' );
r = it.return();
t.equal( r.value, void 0, 'returns expected value' );
t.equal( r.done, true, 'returns expected value' );
r = it.next();
t.equal( r.value, void 0, 'returns expected value' );
t.equal( r.done, true, 'returns expected value' );
t.end();
});
tape( 'the returned iterator has a `return` method for closing an iterator (argument)', function test( t ) {
var it;
var r;
it = iterAhavercos( uniform( 0.0, 1.0 ) );
r = it.next();
t.equal( typeof r.value, 'number', 'returns a number' );
t.equal( r.done, false, 'returns expected value' );
r = it.next();
t.equal( typeof r.value, 'number', 'returns a number' );
t.equal( r.done, false, 'returns expected value' );
r = it.return( 'finished' );
t.equal( r.value, 'finished', 'returns expected value' );
t.equal( r.done, true, 'returns expected value' );
r = it.next();
t.equal( r.value, void 0, 'returns expected value' );
t.equal( r.done, true, 'returns expected value' );
t.end();
});
```
|
Ridala () was a rural municipality of Estonia, in Lääne County. It had a population of 3,245 (2016) and an area of .
In 2007 it was merged with the city of Haapsalu to establish the Haapsalu urban municipality.
Part of the parish is within the Matsalu National Park.
Populated places
Ridala Parish had two small boroughs and 56 villages.
Small boroughs
Paralepa, Uuemõisa
Villages
Aamse, Allika, Ammuta, Emmuvere, Erja, Espre, Haeska, Herjava, Hobulaiu, Jõõdre, Kabrametsa, Kadaka, Kaevere, Kiideva, Kiltsi, Kiviküla, Koheri, Koidu, Kolila, Kolu, Käpla, Laheva, Lannuste, Liivaküla, Litu, Lõbe, Metsaküla, Mäeküla, Mägari, Nõmme, Panga, Parila, Puiatu, Puise, Pusku, Põgari-Sassi, Rohense, Rohuküla, Rummu, Saanika, Saardu, Sepaküla, Sinalepa, Suure-Ahli, Tammiku, Tanska, Tuuru, Uneste, Uuemõisa, Valgevälja, Varni, Vilkla, Võnnu, Väike-Ahli, Vätse, Üsse.
See also
Matsalu National Park
Pullapää crisis
References
Former municipalities of Estonia
Ridala Parish
|
The European Transport Workers' Federation (ETF) represents over 5 million transport workers from more than 200 transport unions across Europe, from the European Union, the European Economic Area, and Central and Eastern Europe, in over 30 countries.
ETF's work is driven by its vision for Fair Transport: quality jobs with safe, reliable transport services for customers.
Leadership
Presidents
1999: Wilhelm Haberzettl
2009: Graham Stevenson
2012: Lars Lindgren
2017: Frank Moreels
General Secretaries
1999: Doro Zinke
2005: Eduardo Chagas
2019: Livia Spera
References
External links
Maritime organizations
Aviation organizations
European Trade Union Confederation
Organizations established in 1999
|
```objective-c
// objectrenderer.h
//
// Original version by Chris Laurel <claurel@gmail.com>
//
// This program is free software; you can redistribute it and/or
// as published by the Free Software Foundation; either version 2
#pragma once
#include <cstdint>
#include "octree.h"
class Observer;
class Renderer;
template<class OBJ, class PREC>
class ObjectRenderer : public celestia::engine::OctreeProcessor<OBJ, PREC>
{
public:
const Observer* observer { nullptr };
Renderer* renderer { nullptr };
float pixelSize { 0.0f };
float faintestMag { 0.0f };
float distanceLimit { 0.0f };
// Objects brighter than labelThresholdMag will be labeled
float labelThresholdMag { 0.0f };
std::uint64_t renderFlags { 0 };
int labelMode { 0 };
protected:
explicit ObjectRenderer(PREC _distanceLimit) :
distanceLimit(static_cast<float>(_distanceLimit))
{
}
};
```
|
Konectbus is a bus operator based in Dereham in Norfolk, England. It is a subsidiary of the Go-Ahead Group and forms part of Go East Anglia.
History
Konectbus was formed in 1999 when the Saham Toney depot of Norfolk Green was purchased from with four coaches, originally trading as Konect. The company moved out of coach operations and into tendered bus services. In 2003, the company was renamed Konectbus.
In 2004, the depot was relocated to Toftwood. In March 2013, a new depot was opened in Rashes Green Industrial Estate. In 2005, Konectbus began to operate two park & ride services under contract to Norfolk County Council.
In March 2010, Konectbus was sold to the Go-Ahead Group. In November 2017 Konectbus took over all seventeen routes and twenty buses of sister company Anglian Bus.
Acquisitions
Anglian Bus was a bus operator based in Beccles. A subsidiary of the Go-Ahead Group, it operated services in both Norfolk and Suffolk from 1981 until 2017.
Anglian Bus was formed in 1981 by David and Christine Pursey, operating charter services and school services from a depot in Loddon. In January 1999, Anglian Bus began operating its first public bus service numbered 580 between Diss and Great Yarmouth under contract to Norfolk County Council.
In October 2000, the depot was relocated to Beccles Business Park, where a purpose built garage was constructed on of freehold land. This depot had a MOT testing facility. In 2003, the company began its first commercial service from Halesworth to Norwich. In 2004, a second depot at New Rackheath, near Norwich opened. It has since closed and is now used as an outstation by sister company Konectbus.
In April 2012, Anglian Bus was sold to the Go-Ahead Group. On 19 November 2017, Anglian Bus ceased trading with all routes and buses transferred to Konectbus.
Anglian Bus operated a number of services, both standard routes and more limited services. Both urban and rural areas were served, with many of the company's routes running into the city of Norwich serving Norwich bus station. Great Yarmouth and Lowestoft were also served by many routes. At the time operations ceased in November 2017, the fleet comprised twenty vehicles.
Services
Konectbus operate services in Norfolk and Suffolk. On 7 September 2015, Konectbus started operating a five-year contract for all six Norwich park & ride services.
Former Services
The company formerly operated route X6 from Thetford to Norwich via Attleborough. It was withdrawn in 2019.
Fleet
As of October 2017, the fleet consisted of 61 buses.
References
External links
Company website
Official website (archive copy)
Bus operators in Norfolk
Go-Ahead Group companies
Transport companies established in 1999
1999 establishments in England
Transport companies established in 1981
Transport companies disestablished in 2017
1981 establishments in England
2017 disestablishments in England
|
```javascript
/**
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
'use strict';
// MODULES //
var nullary = require( '@stdlib/strided/base/nullary' ).ndarray;
var binary = require( '@stdlib/strided/base/binary' ).ndarray;
var prng = require( './prng.js' );
// MAIN //
/**
* Fills a strided array with pseudorandom numbers drawn from a Weibull distribution.
*
* @param {NonNegativeInteger} N - number of indexed elements
* @param {Collection} k - scale parameter
* @param {integer} sk - `k` stride length
* @param {NonNegativeInteger} ok - starting `k` index
* @param {Collection} lambda - shape parameter
* @param {integer} sl - `lambda` stride length
* @param {NonNegativeInteger} ol - starting `lambda` index
* @param {Collection} out - output array
* @param {integer} so - `out` stride length
* @param {NonNegativeInteger} oo - starting `out` index
* @param {Options} [options] - function options
* @param {PRNG} [options.prng] - pseudorandom number generator which generates uniformly distributed pseudorandom numbers
* @param {PRNGSeedMT19937} [options.seed] - pseudorandom number generator seed
* @param {PRNGStateMT19937} [options.state] - pseudorandom number generator state
* @param {boolean} [options.copy=true] - boolean indicating whether to copy a provided pseudorandom number generator state
* @throws {Error} must provide valid distribution parameters
* @throws {Error} must provide valid options
* @throws {Error} must provide a valid state
* @returns {Collection} output array
*
* @example
* var Float64Array = require( '@stdlib/array/float64' );
*
* // Create an array:
* var out = new Float64Array( 10 );
*
* // Fill the array with pseudorandom numbers:
* weibull( out.length, [ 2.0 ], 0, 0, [ 5.0 ], 0, 0, out, 1, 0 );
*/
function weibull( N, k, sk, ok, lambda, sl, ol, out, so, oo, options ) { // eslint-disable-line max-params
var rand = prng( k, sk, ok, lambda, sl, ol, arguments.length > 10, options ); // eslint-disable-line max-len
if ( rand.arity === 0 ) {
nullary( [ out ], [ N ], [ so ], [ oo ], rand.fcn );
return out;
}
binary( [ k, lambda, out ], [ N ], [ sk, sl, so ], [ ok, ol, oo ], rand.fcn ); // eslint-disable-line max-len
return out;
}
// EXPORTS //
module.exports = weibull;
```
|
The Dessauer Marsch (Armeemarsch I, 1b) is a slow infantry march.
It is believed that the march originated from Italy. The melody of a folk song was played for Leopold I, Prince of Anhalt-Dessau after the Battle of Cassano (1705). He enjoyed the march so much, that by the time of the Battle of Turin (1706) the march was played at his entrance to the city. One of the Dessauer Marsch's most distinctive features is its elaborate trumpet solos. Up until World War I, the march was the presentation march of the Infantry Regiment Fürst Leopold von Anhalt-Dessau No. 26.
References
Hans-Peter Stein: Transfeldt. Wort und Brauch in Heer und Flotte. 9., überarbeitete und erweiterte Auflage. Stuttgart 1986.
External links
Text des Dessauer Marsches
German military marches
Year of song unknown
|
```java
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package org.ballerinalang.langserver;
import org.ballerinalang.langserver.commons.registration.BallerinaServerCapability;
import org.ballerinalang.langserver.commons.registration.BallerinaServerCapabilitySetter;
import java.util.ArrayList;
import java.util.List;
import java.util.ServiceLoader;
/**
* Extended server capability setter.
* This utility is responsible for setting the capabilities
*
* @since 2.0.0
*/
public class ExtendedServerCapabilityBuilder {
private static List<BallerinaServerCapabilitySetter<? extends BallerinaServerCapability>> capabilitySetters;
private ExtendedServerCapabilityBuilder() {
}
/**
* Get the extended server capabilities supported by the sever.
*
* @return {@link List}
*/
public static List<BallerinaServerCapability> get() {
if (capabilitySetters == null) {
capabilitySetters = new ArrayList<>();
ServiceLoader<BallerinaServerCapabilitySetter> loader
= ServiceLoader.load(BallerinaServerCapabilitySetter.class);
for (BallerinaServerCapabilitySetter<?> capabilitySetter : loader) {
capabilitySetters.add(capabilitySetter);
}
}
List<BallerinaServerCapability> serverCapabilities = new ArrayList<>();
for (BallerinaServerCapabilitySetter<? extends BallerinaServerCapability> capabilitySetter
: capabilitySetters) {
capabilitySetter.build().ifPresent(serverCapabilities::add);
}
return serverCapabilities;
}
}
```
|
```smalltalk
/*****************************************************************************
*
* ReoGrid - .NET Spreadsheet Control
*
* path_to_url
*
* THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
* KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
* PURPOSE.
*
* Author: Jingwood <jingwood at unvell.com>
*
*
****************************************************************************/
#if WINFORM || ANDROID
using RGFloat = System.Single;
using RGIntDouble = System.Int32;
#elif WPF
using RGFloat = System.Double;
using RGIntDouble = System.Double;
#elif iOS
using RGFloat = System.Double;
using RGIntDouble = System.Double;
#endif
using System.Collections.Generic;
using System.Diagnostics;
using unvell.ReoGrid.Graphics;
using unvell.ReoGrid.Rendering;
using unvell.ReoGrid.Interaction;
using unvell.ReoGrid.Main;
namespace unvell.ReoGrid.Views
{
/// <summary>
/// A view is a visual region which can be independent rendered on ReoGrid control.
/// A view can contains multiple child views.
/// </summary>
interface IView : IUserVisual
{
IViewportController ViewportController { get; set; }
Rectangle Bounds { get; set; }
RGFloat Left { get; }
RGFloat Top { get; }
RGFloat Width { get; }
RGFloat Height { get; }
RGFloat Right { get; }
RGFloat Bottom { get; }
void UpdateView();
RGFloat ScaleFactor { get; set; }
bool PerformTransform { get; set; }
void Draw(CellDrawingContext dc);
void DrawChildren(CellDrawingContext dc);
bool Visible { get; set; }
Point PointToView(Point p);
Point PointToController(Point p);
IView GetViewByPoint(Point p);
IList<IView> Children { get; set; }
}
}
```
|
Kim Sæther (born 1975 at Lille Skensved, near Køge), better known as DJ Noize is a Copenhagen-based Danish hip-hop-DJ. His company, Noizeworks places all his activities under one moniker.
Career
DJ Noize started scratching in his local youth club at the age of 13 getting his own pair of Technics 1210 turntables at the age of 15. DJ Noize won Danish master titles in 1993, 1994, 1995, 1996 and 2000 and the New Music Seminar DJ Battle (then called "Clark Kent's Superman Battle for World Supremacy" and MC'd by DJ Clark Kent) in New York City against DJ 8-Ball in the summer of 1994 – the first white non-American to ever win. He won second place at the prestigious DMC World DJ Championships in 1994 and 1995. He became World Champion at the DMC World DJ Championships in 1996. He is famous for his battle performances and wordplay – dicing words from vinyls to produce cheeky disses of his opponents.
He tours the world judging DJ battles and competitions. He has performed with the Freestyle MC Supernatural, and has opened sets for prominent names such as Erykah Badu, GangStarr and Grandmaster Flash among others.
He hosted his own radio programme showcasing hip-hop on Denmark's Radio for nine years, starting in 1997.
His known personal projects include Nobody Beats The Beats, Skinnyman, the DJ outfit Denmark’s Finest together with DJ Static and DJ Shine, working with the Danish needle company Ortofon and lately he has become one-fifth of the Majors together with DJ Static, Negash Ali, Nat III and J-Spliff.
Solo work
1996: The Whole Mess (LP)
1999: The Whole Mess part 2 (1999) (LP)
1999: The Whole Mess parts 1 & 2 (1999) (CD)
2000: Fantastic feat. Maylay Sparks / it's a demo 2000 feat. Freestyle (12")
Collaborations
1996: Various Artists / RAPOMANIA vol. 1 (CD)
1996: Drop Dead - Hip Hop Til Folket / (CD / LP)
1999: Double Mouth / Rhymes Ahead (CD)
1999: Various Artists / Global Networking (CD)
1999: Massinfluence / The Underground Science (CD / LP)
2001: Urban Broadcast / Live Transmission (12")
2001: Various Artists / ScandalNavia vol. 1 (CD)
2002: Nobody Beats The Beats / Nobody Beats The Beat (CD)
2003: Nobody Beats The Beats / Nobody Beats The Beat The Second Coming (CD / LP)
2003: Danskrap.dk / Så Ka’ I Lære Det (CD)
2004: Nobody Beats The Beats / Nobody Beats The Beat Drops From Above (CD)
2004: Various Artists / Cph Claimin' Respect #2 (12")
2004: Freestyle / Etched in Stone (CD / LP)
2005: Various Artists / Ciphersounds vol.1 (Free MP3)
2006: Beatman & Rockin' / Who's Supa Now (CD)
2006: Static & Nat Ill / Teamwork (CD / LP)
2007: Per Vers feat DJ Noize / Vers 64.0 (a two player game) (CD mixtape)
2007: Various Artists / Flamingo Files Vol.1 (mixed by DJ Noize) (CD)
2008: Majors / Majors (CD / LP)
2007: "Noget Saerligt", "We Fell", "Come Down Jesus" & "The Dream", Gabriel Flies records (single)
2010: KVBeats / The Résumé (LP)
References
External links
DMC World DJ Championships 2000 DJ Noize
DJ Noize Battles with American DJ Shortkut at the New Musik Seminar DJ Battle 1994
DJ Noize Battles with American DJ 8-ball at the New Musik Seminar DJ Battle 1994
1975 births
Living people
Danish DJs
Danish hip hop musicians
People from Køge Municipality
Electronic dance music DJs
|
```c++
//
//
// This header is generated from the Khronos Vulkan XML API Registry.
#ifndef VULKAN_HPP
#define VULKAN_HPP
#include <algorithm>
#include <array> // ArrayWrapperND
#include <string.h> // strnlen
#include <string> // std::string
#include <utility> // std::exchange
#include <vulkan/vulkan.h>
#include <vulkan/vulkan_hpp_macros.hpp>
#if 17 <= VULKAN_HPP_CPP_VERSION
# include <string_view>
#endif
#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
# include <tuple> // std::tie
# include <vector> // std::vector
#endif
#if !defined( VULKAN_HPP_NO_EXCEPTIONS )
# include <system_error> // std::is_error_code_enum
#endif
#if ( VULKAN_HPP_ASSERT == assert )
# include <cassert>
#endif
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
# include <dlfcn.h>
# elif defined( _WIN32 ) && !defined( VULKAN_HPP_NO_WIN32_PROTOTYPES )
using HINSTANCE = struct HINSTANCE__ *;
# if defined( _WIN64 )
using FARPROC = int64_t( __stdcall * )();
# else
using FARPROC = int( __stdcall * )();
# endif
extern "C" __declspec( dllimport ) HINSTANCE __stdcall LoadLibraryA( char const * lpLibFileName );
extern "C" __declspec( dllimport ) int __stdcall FreeLibrary( HINSTANCE hLibModule );
extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE hModule, const char * lpProcName );
# endif
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
# include <compare>
#endif
#if defined( VULKAN_HPP_SUPPORT_SPAN )
# include <span>
#endif
static_assert( VK_HEADER_VERSION == 293, "Wrong VK_HEADER_VERSION!" );
// <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x)
// which is an expression in a constructor initializer list.
#if defined( major )
# undef major
#endif
#if defined( minor )
# undef minor
#endif
// Windows defines MemoryBarrier which is deprecated and collides
// with the VULKAN_HPP_NAMESPACE::MemoryBarrier struct.
#if defined( MemoryBarrier )
# undef MemoryBarrier
#endif
// XLib.h defines True/False, which collides with our vk::True/vk::False
// -> undef them and provide some namepace-secure constexpr
#if defined( True )
# undef True
constexpr int True = 1;
#endif
#if defined( False )
# undef False
constexpr int False = 0;
#endif
namespace VULKAN_HPP_NAMESPACE
{
template <typename T, size_t N>
class ArrayWrapper1D : public std::array<T, N>
{
public:
VULKAN_HPP_CONSTEXPR ArrayWrapper1D() VULKAN_HPP_NOEXCEPT : std::array<T, N>() {}
VULKAN_HPP_CONSTEXPR ArrayWrapper1D( std::array<T, N> const & data ) VULKAN_HPP_NOEXCEPT : std::array<T, N>( data ) {}
template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
VULKAN_HPP_CONSTEXPR_14 ArrayWrapper1D( std::string const & data ) VULKAN_HPP_NOEXCEPT
{
copy( data.data(), data.length() );
}
#if 17 <= VULKAN_HPP_CPP_VERSION
template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
VULKAN_HPP_CONSTEXPR_14 ArrayWrapper1D( std::string_view data ) VULKAN_HPP_NOEXCEPT
{
copy( data.data(), data.length() );
}
#endif
#if ( VK_USE_64_BIT_PTR_DEFINES == 0 )
// on 32 bit compiles, needs overloads on index type int to resolve ambiguities
VULKAN_HPP_CONSTEXPR T const & operator[]( int index ) const VULKAN_HPP_NOEXCEPT
{
return std::array<T, N>::operator[]( index );
}
T & operator[]( int index ) VULKAN_HPP_NOEXCEPT
{
return std::array<T, N>::operator[]( index );
}
#endif
operator T const *() const VULKAN_HPP_NOEXCEPT
{
return this->data();
}
operator T *() VULKAN_HPP_NOEXCEPT
{
return this->data();
}
template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
operator std::string() const
{
return std::string( this->data(), strnlen( this->data(), N ) );
}
#if 17 <= VULKAN_HPP_CPP_VERSION
template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
operator std::string_view() const
{
return std::string_view( this->data(), strnlen( this->data(), N ) );
}
#endif
private:
VULKAN_HPP_CONSTEXPR_14 void copy( char const * data, size_t len ) VULKAN_HPP_NOEXCEPT
{
size_t n = ( std::min )( N - 1, len );
for ( size_t i = 0; i < n; ++i )
{
( *this )[i] = data[i];
}
( *this )[n] = 0;
}
};
// relational operators between ArrayWrapper1D of chars with potentially different sizes
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
template <size_t N, size_t M>
std::strong_ordering operator<=>( ArrayWrapper1D<char, N> const & lhs, ArrayWrapper1D<char, M> const & rhs ) VULKAN_HPP_NOEXCEPT
{
int result = strcmp( lhs.data(), rhs.data() );
return ( result < 0 ) ? std::strong_ordering::less : ( ( result > 0 ) ? std::strong_ordering::greater : std::strong_ordering::equal );
}
#else
template <size_t N, size_t M>
bool operator<( ArrayWrapper1D<char, N> const & lhs, ArrayWrapper1D<char, M> const & rhs ) VULKAN_HPP_NOEXCEPT
{
return strcmp( lhs.data(), rhs.data() ) < 0;
}
template <size_t N, size_t M>
bool operator<=( ArrayWrapper1D<char, N> const & lhs, ArrayWrapper1D<char, M> const & rhs ) VULKAN_HPP_NOEXCEPT
{
return strcmp( lhs.data(), rhs.data() ) <= 0;
}
template <size_t N, size_t M>
bool operator>( ArrayWrapper1D<char, N> const & lhs, ArrayWrapper1D<char, M> const & rhs ) VULKAN_HPP_NOEXCEPT
{
return strcmp( lhs.data(), rhs.data() ) > 0;
}
template <size_t N, size_t M>
bool operator>=( ArrayWrapper1D<char, N> const & lhs, ArrayWrapper1D<char, M> const & rhs ) VULKAN_HPP_NOEXCEPT
{
return strcmp( lhs.data(), rhs.data() ) >= 0;
}
#endif
template <size_t N, size_t M>
bool operator==( ArrayWrapper1D<char, N> const & lhs, ArrayWrapper1D<char, M> const & rhs ) VULKAN_HPP_NOEXCEPT
{
return strcmp( lhs.data(), rhs.data() ) == 0;
}
template <size_t N, size_t M>
bool operator!=( ArrayWrapper1D<char, N> const & lhs, ArrayWrapper1D<char, M> const & rhs ) VULKAN_HPP_NOEXCEPT
{
return strcmp( lhs.data(), rhs.data() ) != 0;
}
// specialization of relational operators between std::string and arrays of chars
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
template <size_t N>
std::strong_ordering operator<=>( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
{
return lhs <=> rhs.data();
}
#else
template <size_t N>
bool operator<( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
{
return lhs < rhs.data();
}
template <size_t N>
bool operator<=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
{
return lhs <= rhs.data();
}
template <size_t N>
bool operator>( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
{
return lhs > rhs.data();
}
template <size_t N>
bool operator>=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
{
return lhs >= rhs.data();
}
#endif
template <size_t N>
bool operator==( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
{
return lhs == rhs.data();
}
template <size_t N>
bool operator!=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
{
return lhs != rhs.data();
}
template <typename T, size_t N, size_t M>
class ArrayWrapper2D : public std::array<ArrayWrapper1D<T, M>, N>
{
public:
VULKAN_HPP_CONSTEXPR ArrayWrapper2D() VULKAN_HPP_NOEXCEPT : std::array<ArrayWrapper1D<T, M>, N>() {}
VULKAN_HPP_CONSTEXPR ArrayWrapper2D( std::array<std::array<T, M>, N> const & data ) VULKAN_HPP_NOEXCEPT
: std::array<ArrayWrapper1D<T, M>, N>( *reinterpret_cast<std::array<ArrayWrapper1D<T, M>, N> const *>( &data ) )
{
}
};
#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
template <typename T>
class ArrayProxy
{
public:
VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT
: m_count( 0 )
, m_ptr( nullptr )
{
}
VULKAN_HPP_CONSTEXPR ArrayProxy( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
: m_count( 0 )
, m_ptr( nullptr )
{
}
ArrayProxy( T const & value ) VULKAN_HPP_NOEXCEPT
: m_count( 1 )
, m_ptr( &value )
{
}
ArrayProxy( uint32_t count, T const * ptr ) VULKAN_HPP_NOEXCEPT
: m_count( count )
, m_ptr( ptr )
{
}
template <std::size_t C>
ArrayProxy( T const ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
: m_count( C )
, m_ptr( ptr )
{
}
# if __GNUC__ >= 9
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Winit-list-lifetime"
# endif
ArrayProxy( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT
: m_count( static_cast<uint32_t>( list.size() ) )
, m_ptr( list.begin() )
{
}
template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxy( std::initializer_list<typename std::remove_const<T>::type> const & list ) VULKAN_HPP_NOEXCEPT
: m_count( static_cast<uint32_t>( list.size() ) )
, m_ptr( list.begin() )
{
}
# if __GNUC__ >= 9
# pragma GCC diagnostic pop
# endif
// Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly
// convertible to size_t. The const version can capture temporaries, with lifetime ending at end of statement.
template <typename V,
typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
ArrayProxy( V const & v ) VULKAN_HPP_NOEXCEPT
: m_count( static_cast<uint32_t>( v.size() ) )
, m_ptr( v.data() )
{
}
const T * begin() const VULKAN_HPP_NOEXCEPT
{
return m_ptr;
}
const T * end() const VULKAN_HPP_NOEXCEPT
{
return m_ptr + m_count;
}
const T & front() const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_count && m_ptr );
return *m_ptr;
}
const T & back() const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_count && m_ptr );
return *( m_ptr + m_count - 1 );
}
bool empty() const VULKAN_HPP_NOEXCEPT
{
return ( m_count == 0 );
}
uint32_t size() const VULKAN_HPP_NOEXCEPT
{
return m_count;
}
T const * data() const VULKAN_HPP_NOEXCEPT
{
return m_ptr;
}
private:
uint32_t m_count;
T const * m_ptr;
};
template <typename T>
class ArrayProxyNoTemporaries
{
public:
VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries() VULKAN_HPP_NOEXCEPT
: m_count( 0 )
, m_ptr( nullptr )
{
}
VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
: m_count( 0 )
, m_ptr( nullptr )
{
}
template <typename B = T, typename std::enable_if<std::is_convertible<B, T>::value && std::is_lvalue_reference<B>::value, int>::type = 0>
ArrayProxyNoTemporaries( B && value ) VULKAN_HPP_NOEXCEPT
: m_count( 1 )
, m_ptr( &value )
{
}
ArrayProxyNoTemporaries( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT
: m_count( count )
, m_ptr( ptr )
{
}
template <std::size_t C>
ArrayProxyNoTemporaries( T ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
: m_count( C )
, m_ptr( ptr )
{
}
template <std::size_t C>
ArrayProxyNoTemporaries( T ( &&ptr )[C] ) = delete;
// Any l-value reference with a .data() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t.
template <typename V,
typename std::enable_if<!std::is_convertible<decltype( std::declval<V>().begin() ), T *>::value &&
std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value && std::is_lvalue_reference<V>::value,
int>::type = 0>
ArrayProxyNoTemporaries( V && v ) VULKAN_HPP_NOEXCEPT
: m_count( static_cast<uint32_t>( v.size() ) )
, m_ptr( v.data() )
{
}
// Any l-value reference with a .begin() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t.
template <typename V,
typename std::enable_if<std::is_convertible<decltype( std::declval<V>().begin() ), T *>::value &&
std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value && std::is_lvalue_reference<V>::value,
int>::type = 0>
ArrayProxyNoTemporaries( V && v ) VULKAN_HPP_NOEXCEPT
: m_count( static_cast<uint32_t>( v.size() ) )
, m_ptr( v.begin() )
{
}
const T * begin() const VULKAN_HPP_NOEXCEPT
{
return m_ptr;
}
const T * end() const VULKAN_HPP_NOEXCEPT
{
return m_ptr + m_count;
}
const T & front() const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_count && m_ptr );
return *m_ptr;
}
const T & back() const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_count && m_ptr );
return *( m_ptr + m_count - 1 );
}
bool empty() const VULKAN_HPP_NOEXCEPT
{
return ( m_count == 0 );
}
uint32_t size() const VULKAN_HPP_NOEXCEPT
{
return m_count;
}
T * data() const VULKAN_HPP_NOEXCEPT
{
return m_ptr;
}
private:
uint32_t m_count;
T * m_ptr;
};
template <typename T>
class StridedArrayProxy : protected ArrayProxy<T>
{
public:
using ArrayProxy<T>::ArrayProxy;
StridedArrayProxy( uint32_t count, T const * ptr, uint32_t stride ) VULKAN_HPP_NOEXCEPT
: ArrayProxy<T>( count, ptr )
, m_stride( stride )
{
VULKAN_HPP_ASSERT( sizeof( T ) <= stride );
}
using ArrayProxy<T>::begin;
const T * end() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<T const *>( static_cast<uint8_t const *>( begin() ) + size() * m_stride );
}
using ArrayProxy<T>::front;
const T & back() const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( begin() && size() );
return *reinterpret_cast<T const *>( static_cast<uint8_t const *>( begin() ) + ( size() - 1 ) * m_stride );
}
using ArrayProxy<T>::empty;
using ArrayProxy<T>::size;
using ArrayProxy<T>::data;
uint32_t stride() const
{
return m_stride;
}
private:
uint32_t m_stride = sizeof( T );
};
template <typename RefType>
class Optional
{
public:
Optional( RefType & reference ) VULKAN_HPP_NOEXCEPT
{
m_ptr = &reference;
}
Optional( RefType * ptr ) VULKAN_HPP_NOEXCEPT
{
m_ptr = ptr;
}
Optional( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_ptr = nullptr;
}
operator RefType *() const VULKAN_HPP_NOEXCEPT
{
return m_ptr;
}
RefType const * operator->() const VULKAN_HPP_NOEXCEPT
{
return m_ptr;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return !!m_ptr;
}
private:
RefType * m_ptr;
};
template <typename X, typename Y>
struct StructExtends
{
enum
{
value = false
};
};
template <typename Type, class...>
struct IsPartOfStructureChain
{
static const bool valid = false;
};
template <typename Type, typename Head, typename... Tail>
struct IsPartOfStructureChain<Type, Head, Tail...>
{
static const bool valid = std::is_same<Type, Head>::value || IsPartOfStructureChain<Type, Tail...>::valid;
};
template <size_t Index, typename T, typename... ChainElements>
struct StructureChainContains
{
static const bool value = std::is_same<T, typename std::tuple_element<Index, std::tuple<ChainElements...>>::type>::value ||
StructureChainContains<Index - 1, T, ChainElements...>::value;
};
template <typename T, typename... ChainElements>
struct StructureChainContains<0, T, ChainElements...>
{
static const bool value = std::is_same<T, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value;
};
template <size_t Index, typename... ChainElements>
struct StructureChainValidation
{
using TestType = typename std::tuple_element<Index, std::tuple<ChainElements...>>::type;
static const bool valid = StructExtends<TestType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value &&
( TestType::allowDuplicate || !StructureChainContains<Index - 1, TestType, ChainElements...>::value ) &&
StructureChainValidation<Index - 1, ChainElements...>::valid;
};
template <typename... ChainElements>
struct StructureChainValidation<0, ChainElements...>
{
static const bool valid = true;
};
template <typename... ChainElements>
class StructureChain : public std::tuple<ChainElements...>
{
public:
StructureChain() VULKAN_HPP_NOEXCEPT
{
static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
link<sizeof...( ChainElements ) - 1>();
}
StructureChain( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( rhs )
{
static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
link( &std::get<0>( *this ),
&std::get<0>( rhs ),
reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
}
StructureChain( StructureChain && rhs ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( std::forward<std::tuple<ChainElements...>>( rhs ) )
{
static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
link( &std::get<0>( *this ),
&std::get<0>( rhs ),
reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
}
StructureChain( ChainElements const &... elems ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( elems... )
{
static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
link<sizeof...( ChainElements ) - 1>();
}
StructureChain & operator=( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT
{
std::tuple<ChainElements...>::operator=( rhs );
link( &std::get<0>( *this ),
&std::get<0>( rhs ),
reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
return *this;
}
StructureChain & operator=( StructureChain && rhs ) = delete;
template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
T & get() VULKAN_HPP_NOEXCEPT
{
return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>( static_cast<std::tuple<ChainElements...> &>( *this ) );
}
template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
T const & get() const VULKAN_HPP_NOEXCEPT
{
return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>( static_cast<std::tuple<ChainElements...> const &>( *this ) );
}
template <typename T0, typename T1, typename... Ts>
std::tuple<T0 &, T1 &, Ts &...> get() VULKAN_HPP_NOEXCEPT
{
return std::tie( get<T0>(), get<T1>(), get<Ts>()... );
}
template <typename T0, typename T1, typename... Ts>
std::tuple<T0 const &, T1 const &, Ts const &...> get() const VULKAN_HPP_NOEXCEPT
{
return std::tie( get<T0>(), get<T1>(), get<Ts>()... );
}
// assign a complete structure to the StructureChain without modifying the chaining
template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
StructureChain & assign( const T & rhs ) VULKAN_HPP_NOEXCEPT
{
T & lhs = get<T, Which>();
auto pNext = lhs.pNext;
lhs = rhs;
lhs.pNext = pNext;
return *this;
}
template <typename ClassType, size_t Which = 0>
typename std::enable_if<std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value && ( Which == 0 ), bool>::type
isLinked() const VULKAN_HPP_NOEXCEPT
{
return true;
}
template <typename ClassType, size_t Which = 0>
typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), bool>::type
isLinked() const VULKAN_HPP_NOEXCEPT
{
static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
return isLinked( reinterpret_cast<VkBaseInStructure const *>( &get<ClassType, Which>() ) );
}
template <typename ClassType, size_t Which = 0>
typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
relink() VULKAN_HPP_NOEXCEPT
{
static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't relink Structure that's not part of this StructureChain!" );
auto pNext = reinterpret_cast<VkBaseInStructure *>( &get<ClassType, Which>() );
VULKAN_HPP_ASSERT( !isLinked( pNext ) );
auto & headElement = std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) );
pNext->pNext = reinterpret_cast<VkBaseInStructure const *>( headElement.pNext );
headElement.pNext = pNext;
}
template <typename ClassType, size_t Which = 0>
typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
unlink() VULKAN_HPP_NOEXCEPT
{
static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
unlink( reinterpret_cast<VkBaseOutStructure const *>( &get<ClassType, Which>() ) );
}
private:
template <int Index, typename T, int Which, typename, class First, class... Types>
struct ChainElementIndex : ChainElementIndex<Index + 1, T, Which, void, Types...>
{
};
template <int Index, typename T, int Which, class First, class... Types>
struct ChainElementIndex<Index, T, Which, typename std::enable_if<!std::is_same<T, First>::value, void>::type, First, Types...>
: ChainElementIndex<Index + 1, T, Which, void, Types...>
{
};
template <int Index, typename T, int Which, class First, class... Types>
struct ChainElementIndex<Index, T, Which, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
: ChainElementIndex<Index + 1, T, Which - 1, void, Types...>
{
};
template <int Index, typename T, class First, class... Types>
struct ChainElementIndex<Index, T, 0, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
: std::integral_constant<int, Index>
{
};
bool isLinked( VkBaseInStructure const * pNext ) const VULKAN_HPP_NOEXCEPT
{
VkBaseInStructure const * elementPtr =
reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( static_cast<std::tuple<ChainElements...> const &>( *this ) ) );
while ( elementPtr )
{
if ( elementPtr->pNext == pNext )
{
return true;
}
elementPtr = elementPtr->pNext;
}
return false;
}
template <size_t Index>
typename std::enable_if<Index != 0, void>::type link() VULKAN_HPP_NOEXCEPT
{
auto & x = std::get<Index - 1>( static_cast<std::tuple<ChainElements...> &>( *this ) );
x.pNext = &std::get<Index>( static_cast<std::tuple<ChainElements...> &>( *this ) );
link<Index - 1>();
}
template <size_t Index>
typename std::enable_if<Index == 0, void>::type link() VULKAN_HPP_NOEXCEPT
{
}
void link( void * dstBase, void const * srcBase, VkBaseOutStructure * dst, VkBaseInStructure const * src )
{
while ( src->pNext )
{
std::ptrdiff_t offset = reinterpret_cast<char const *>( src->pNext ) - reinterpret_cast<char const *>( srcBase );
dst->pNext = reinterpret_cast<VkBaseOutStructure *>( reinterpret_cast<char *>( dstBase ) + offset );
dst = dst->pNext;
src = src->pNext;
}
dst->pNext = nullptr;
}
void unlink( VkBaseOutStructure const * pNext ) VULKAN_HPP_NOEXCEPT
{
VkBaseOutStructure * elementPtr = reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) ) );
while ( elementPtr && ( elementPtr->pNext != pNext ) )
{
elementPtr = elementPtr->pNext;
}
if ( elementPtr )
{
elementPtr->pNext = pNext->pNext;
}
else
{
VULKAN_HPP_ASSERT( false ); // fires, if the ClassType member has already been unlinked !
}
}
};
// interupt the VULKAN_HPP_NAMESPACE for a moment to add specializations of std::tuple_size and std::tuple_element for the StructureChain!
}
namespace std
{
template <typename... Elements>
struct tuple_size<VULKAN_HPP_NAMESPACE::StructureChain<Elements...>>
{
static constexpr size_t value = std::tuple_size<std::tuple<Elements...>>::value;
};
template <std::size_t Index, typename... Elements>
struct tuple_element<Index, VULKAN_HPP_NAMESPACE::StructureChain<Elements...>>
{
using type = typename std::tuple_element<Index, std::tuple<Elements...>>::type;
};
} // namespace std
namespace VULKAN_HPP_NAMESPACE
{
# if !defined( VULKAN_HPP_NO_SMART_HANDLE )
template <typename Type, typename Dispatch>
class UniqueHandleTraits;
template <typename Type, typename Dispatch>
class UniqueHandle : public UniqueHandleTraits<Type, Dispatch>::deleter
{
private:
using Deleter = typename UniqueHandleTraits<Type, Dispatch>::deleter;
public:
using element_type = Type;
UniqueHandle() : Deleter(), m_value() {}
explicit UniqueHandle( Type const & value, Deleter const & deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
: Deleter( deleter )
, m_value( value )
{
}
UniqueHandle( UniqueHandle const & ) = delete;
UniqueHandle( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT
: Deleter( std::move( static_cast<Deleter &>( other ) ) )
, m_value( other.release() )
{
}
~UniqueHandle() VULKAN_HPP_NOEXCEPT
{
if ( m_value )
{
this->destroy( m_value );
}
}
UniqueHandle & operator=( UniqueHandle const & ) = delete;
UniqueHandle & operator=( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT
{
reset( other.release() );
*static_cast<Deleter *>( this ) = std::move( static_cast<Deleter &>( other ) );
return *this;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_value.operator bool();
}
# if defined( VULKAN_HPP_SMART_HANDLE_IMPLICIT_CAST )
operator Type() const VULKAN_HPP_NOEXCEPT
{
return m_value;
}
# endif
Type const * operator->() const VULKAN_HPP_NOEXCEPT
{
return &m_value;
}
Type * operator->() VULKAN_HPP_NOEXCEPT
{
return &m_value;
}
Type const & operator*() const VULKAN_HPP_NOEXCEPT
{
return m_value;
}
Type & operator*() VULKAN_HPP_NOEXCEPT
{
return m_value;
}
const Type & get() const VULKAN_HPP_NOEXCEPT
{
return m_value;
}
Type & get() VULKAN_HPP_NOEXCEPT
{
return m_value;
}
void reset( Type const & value = Type() ) VULKAN_HPP_NOEXCEPT
{
if ( m_value != value )
{
if ( m_value )
{
this->destroy( m_value );
}
m_value = value;
}
}
Type release() VULKAN_HPP_NOEXCEPT
{
Type value = m_value;
m_value = nullptr;
return value;
}
void swap( UniqueHandle<Type, Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT
{
std::swap( m_value, rhs.m_value );
std::swap( static_cast<Deleter &>( *this ), static_cast<Deleter &>( rhs ) );
}
private:
Type m_value;
};
template <typename UniqueType>
VULKAN_HPP_INLINE std::vector<typename UniqueType::element_type> uniqueToRaw( std::vector<UniqueType> const & handles )
{
std::vector<typename UniqueType::element_type> newBuffer( handles.size() );
std::transform( handles.begin(), handles.end(), newBuffer.begin(), []( UniqueType const & handle ) { return handle.get(); } );
return newBuffer;
}
template <typename Type, typename Dispatch>
VULKAN_HPP_INLINE void swap( UniqueHandle<Type, Dispatch> & lhs, UniqueHandle<Type, Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT
{
lhs.swap( rhs );
}
# endif
#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
class DispatchLoaderBase
{
public:
DispatchLoaderBase() = default;
DispatchLoaderBase( std::nullptr_t )
#if !defined( NDEBUG )
: m_valid( false )
#endif
{
}
#if !defined( NDEBUG )
size_t getVkHeaderVersion() const
{
VULKAN_HPP_ASSERT( m_valid );
return vkHeaderVersion;
}
private:
size_t vkHeaderVersion = VK_HEADER_VERSION;
bool m_valid = true;
#endif
};
#if !defined( VK_NO_PROTOTYPES )
class DispatchLoaderStatic : public DispatchLoaderBase
{
public:
//=== VK_VERSION_1_0 ===
VkResult
vkCreateInstance( const VkInstanceCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkInstance * pInstance ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance );
}
void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyInstance( instance, pAllocator );
}
VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t * pPhysicalDeviceCount, VkPhysicalDevice * pPhysicalDevices ) const VULKAN_HPP_NOEXCEPT
{
return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices );
}
void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures * pFeatures ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures );
}
void
vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties );
}
VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
VkImageTiling tiling,
VkImageUsageFlags usage,
VkImageCreateFlags flags,
VkImageFormatProperties * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties );
}
void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties );
}
void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice,
uint32_t * pQueueFamilyPropertyCount,
VkQueueFamilyProperties * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
}
void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties );
}
PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char * pName ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetInstanceProcAddr( instance, pName );
}
PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char * pName ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceProcAddr( device, pName );
}
VkResult vkCreateDevice( VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkDevice * pDevice ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice );
}
void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyDevice( device, pAllocator );
}
VkResult vkEnumerateInstanceExtensionProperties( const char * pLayerName,
uint32_t * pPropertyCount,
VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties );
}
VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice,
const char * pLayerName,
uint32_t * pPropertyCount,
VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties );
}
VkResult vkEnumerateInstanceLayerProperties( uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties );
}
VkResult
vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties );
}
void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue );
}
VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
{
return ::vkQueueSubmit( queue, submitCount, pSubmits, fence );
}
VkResult vkQueueWaitIdle( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
{
return ::vkQueueWaitIdle( queue );
}
VkResult vkDeviceWaitIdle( VkDevice device ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDeviceWaitIdle( device );
}
VkResult vkAllocateMemory( VkDevice device,
const VkMemoryAllocateInfo * pAllocateInfo,
const VkAllocationCallbacks * pAllocator,
VkDeviceMemory * pMemory ) const VULKAN_HPP_NOEXCEPT
{
return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory );
}
void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkFreeMemory( device, memory, pAllocator );
}
VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void ** ppData ) const
VULKAN_HPP_NOEXCEPT
{
return ::vkMapMemory( device, memory, offset, size, flags, ppData );
}
void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const VULKAN_HPP_NOEXCEPT
{
return ::vkUnmapMemory( device, memory );
}
VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
{
return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
}
VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
{
return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
}
void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize * pCommittedMemoryInBytes ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes );
}
VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
{
return ::vkBindBufferMemory( device, buffer, memory, memoryOffset );
}
VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
{
return ::vkBindImageMemory( device, image, memory, memoryOffset );
}
void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements );
}
void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements );
}
void vkGetImageSparseMemoryRequirements( VkDevice device,
VkImage image,
uint32_t * pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
}
void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
VkSampleCountFlagBits samples,
VkImageUsageFlags usage,
VkImageTiling tiling,
uint32_t * pPropertyCount,
VkSparseImageFormatProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties );
}
VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo * pBindInfo, VkFence fence ) const VULKAN_HPP_NOEXCEPT
{
return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence );
}
VkResult vkCreateFence( VkDevice device,
const VkFenceCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence );
}
void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyFence( device, fence, pAllocator );
}
VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences ) const VULKAN_HPP_NOEXCEPT
{
return ::vkResetFences( device, fenceCount, pFences );
}
VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetFenceStatus( device, fence );
}
VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences, VkBool32 waitAll, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
{
return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout );
}
VkResult vkCreateSemaphore( VkDevice device,
const VkSemaphoreCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSemaphore * pSemaphore ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore );
}
void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroySemaphore( device, semaphore, pAllocator );
}
VkResult vkCreateEvent( VkDevice device,
const VkEventCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkEvent * pEvent ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent );
}
void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyEvent( device, event, pAllocator );
}
VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetEventStatus( device, event );
}
VkResult vkSetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
{
return ::vkSetEvent( device, event );
}
VkResult vkResetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
{
return ::vkResetEvent( device, event );
}
VkResult vkCreateQueryPool( VkDevice device,
const VkQueryPoolCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkQueryPool * pQueryPool ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool );
}
void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyQueryPool( device, queryPool, pAllocator );
}
VkResult vkGetQueryPoolResults( VkDevice device,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
size_t dataSize,
void * pData,
VkDeviceSize stride,
VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags );
}
VkResult vkCreateBuffer( VkDevice device,
const VkBufferCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkBuffer * pBuffer ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer );
}
void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyBuffer( device, buffer, pAllocator );
}
VkResult vkCreateBufferView( VkDevice device,
const VkBufferViewCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkBufferView * pView ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView );
}
void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyBufferView( device, bufferView, pAllocator );
}
VkResult vkCreateImage( VkDevice device,
const VkImageCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkImage * pImage ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage );
}
void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyImage( device, image, pAllocator );
}
void vkGetImageSubresourceLayout( VkDevice device,
VkImage image,
const VkImageSubresource * pSubresource,
VkSubresourceLayout * pLayout ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout );
}
VkResult vkCreateImageView( VkDevice device,
const VkImageViewCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkImageView * pView ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView );
}
void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyImageView( device, imageView, pAllocator );
}
VkResult vkCreateShaderModule( VkDevice device,
const VkShaderModuleCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkShaderModule * pShaderModule ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule );
}
void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyShaderModule( device, shaderModule, pAllocator );
}
VkResult vkCreatePipelineCache( VkDevice device,
const VkPipelineCacheCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkPipelineCache * pPipelineCache ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache );
}
void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator );
}
VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData );
}
VkResult
vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
{
return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches );
}
VkResult vkCreateGraphicsPipelines( VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkGraphicsPipelineCreateInfo * pCreateInfos,
const VkAllocationCallbacks * pAllocator,
VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
}
VkResult vkCreateComputePipelines( VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo * pCreateInfos,
const VkAllocationCallbacks * pAllocator,
VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
}
void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyPipeline( device, pipeline, pAllocator );
}
VkResult vkCreatePipelineLayout( VkDevice device,
const VkPipelineLayoutCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkPipelineLayout * pPipelineLayout ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout );
}
void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator );
}
VkResult vkCreateSampler( VkDevice device,
const VkSamplerCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSampler * pSampler ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler );
}
void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroySampler( device, sampler, pAllocator );
}
VkResult vkCreateDescriptorSetLayout( VkDevice device,
const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkDescriptorSetLayout * pSetLayout ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout );
}
void vkDestroyDescriptorSetLayout( VkDevice device,
VkDescriptorSetLayout descriptorSetLayout,
const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator );
}
VkResult vkCreateDescriptorPool( VkDevice device,
const VkDescriptorPoolCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkDescriptorPool * pDescriptorPool ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool );
}
void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator );
}
VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
{
return ::vkResetDescriptorPool( device, descriptorPool, flags );
}
VkResult vkAllocateDescriptorSets( VkDevice device,
const VkDescriptorSetAllocateInfo * pAllocateInfo,
VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
{
return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets );
}
VkResult vkFreeDescriptorSets( VkDevice device,
VkDescriptorPool descriptorPool,
uint32_t descriptorSetCount,
const VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
{
return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets );
}
void vkUpdateDescriptorSets( VkDevice device,
uint32_t descriptorWriteCount,
const VkWriteDescriptorSet * pDescriptorWrites,
uint32_t descriptorCopyCount,
const VkCopyDescriptorSet * pDescriptorCopies ) const VULKAN_HPP_NOEXCEPT
{
return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies );
}
VkResult vkCreateFramebuffer( VkDevice device,
const VkFramebufferCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkFramebuffer * pFramebuffer ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer );
}
void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyFramebuffer( device, framebuffer, pAllocator );
}
VkResult vkCreateRenderPass( VkDevice device,
const VkRenderPassCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass );
}
void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyRenderPass( device, renderPass, pAllocator );
}
void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity );
}
VkResult vkCreateCommandPool( VkDevice device,
const VkCommandPoolCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkCommandPool * pCommandPool ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool );
}
void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyCommandPool( device, commandPool, pAllocator );
}
VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
{
return ::vkResetCommandPool( device, commandPool, flags );
}
VkResult vkAllocateCommandBuffers( VkDevice device,
const VkCommandBufferAllocateInfo * pAllocateInfo,
VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
{
return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers );
}
void vkFreeCommandBuffers( VkDevice device,
VkCommandPool commandPool,
uint32_t commandBufferCount,
const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
{
return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers );
}
VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo );
}
VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
{
return ::vkEndCommandBuffer( commandBuffer );
}
VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const VULKAN_HPP_NOEXCEPT
{
return ::vkResetCommandBuffer( commandBuffer, flags );
}
void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline );
}
void
vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports );
}
void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors );
}
void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetLineWidth( commandBuffer, lineWidth );
}
void vkCmdSetDepthBias( VkCommandBuffer commandBuffer,
float depthBiasConstantFactor,
float depthBiasClamp,
float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
}
void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetBlendConstants( commandBuffer, blendConstants );
}
void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds );
}
void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask );
}
void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask );
}
void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference );
}
void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
uint32_t firstSet,
uint32_t descriptorSetCount,
const VkDescriptorSet * pDescriptorSets,
uint32_t dynamicOffsetCount,
const uint32_t * pDynamicOffsets ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindDescriptorSets(
commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets );
}
void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType );
}
void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer,
uint32_t firstBinding,
uint32_t bindingCount,
const VkBuffer * pBuffers,
const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets );
}
void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const
VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
}
void vkCmdDrawIndexed( VkCommandBuffer commandBuffer,
uint32_t indexCount,
uint32_t instanceCount,
uint32_t firstIndex,
int32_t vertexOffset,
uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
}
void vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride );
}
void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride );
}
void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ );
}
void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset );
}
void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy * pRegions ) const
VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions );
}
void vkCmdCopyImage( VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
}
void vkCmdBlitImage( VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageBlit * pRegions,
VkFilter filter ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
}
void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
}
void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
}
void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void * pData ) const
VULKAN_HPP_NOEXCEPT
{
return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData );
}
void
vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data );
}
void vkCmdClearColorImage( VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearColorValue * pColor,
uint32_t rangeCount,
const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges );
}
void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue * pDepthStencil,
uint32_t rangeCount,
const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges );
}
void vkCmdClearAttachments( VkCommandBuffer commandBuffer,
uint32_t attachmentCount,
const VkClearAttachment * pAttachments,
uint32_t rectCount,
const VkClearRect * pRects ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects );
}
void vkCmdResolveImage( VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageResolve * pRegions ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
}
void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetEvent( commandBuffer, event, stageMask );
}
void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdResetEvent( commandBuffer, event, stageMask );
}
void vkCmdWaitEvents( VkCommandBuffer commandBuffer,
uint32_t eventCount,
const VkEvent * pEvents,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
uint32_t memoryBarrierCount,
const VkMemoryBarrier * pMemoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier * pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdWaitEvents( commandBuffer,
eventCount,
pEvents,
srcStageMask,
dstStageMask,
memoryBarrierCount,
pMemoryBarriers,
bufferMemoryBarrierCount,
pBufferMemoryBarriers,
imageMemoryBarrierCount,
pImageMemoryBarriers );
}
void vkCmdPipelineBarrier( VkCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
uint32_t memoryBarrierCount,
const VkMemoryBarrier * pMemoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier * pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdPipelineBarrier( commandBuffer,
srcStageMask,
dstStageMask,
dependencyFlags,
memoryBarrierCount,
pMemoryBarriers,
bufferMemoryBarrierCount,
pBufferMemoryBarriers,
imageMemoryBarrierCount,
pImageMemoryBarriers );
}
void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags );
}
void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdEndQuery( commandBuffer, queryPool, query );
}
void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount );
}
void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
uint32_t query ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query );
}
void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize stride,
VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags );
}
void vkCmdPushConstants( VkCommandBuffer commandBuffer,
VkPipelineLayout layout,
VkShaderStageFlags stageFlags,
uint32_t offset,
uint32_t size,
const void * pValues ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues );
}
void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo * pRenderPassBegin,
VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents );
}
void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdNextSubpass( commandBuffer, contents );
}
void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdEndRenderPass( commandBuffer );
}
void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers );
}
//=== VK_VERSION_1_1 ===
VkResult vkEnumerateInstanceVersion( uint32_t * pApiVersion ) const VULKAN_HPP_NOEXCEPT
{
return ::vkEnumerateInstanceVersion( pApiVersion );
}
VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
{
return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos );
}
VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
{
return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos );
}
void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device,
uint32_t heapIndex,
uint32_t localDeviceIndex,
uint32_t remoteDeviceIndex,
VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
}
void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDeviceMask( commandBuffer, deviceMask );
}
void vkCmdDispatchBase( VkCommandBuffer commandBuffer,
uint32_t baseGroupX,
uint32_t baseGroupY,
uint32_t baseGroupZ,
uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
}
VkResult vkEnumeratePhysicalDeviceGroups( VkInstance instance,
uint32_t * pPhysicalDeviceGroupCount,
VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
}
void vkGetImageMemoryRequirements2( VkDevice device,
const VkImageMemoryRequirementsInfo2 * pInfo,
VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements );
}
void vkGetBufferMemoryRequirements2( VkDevice device,
const VkBufferMemoryRequirementsInfo2 * pInfo,
VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements );
}
void vkGetImageSparseMemoryRequirements2( VkDevice device,
const VkImageSparseMemoryRequirementsInfo2 * pInfo,
uint32_t * pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
}
void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures );
}
void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties );
}
void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties );
}
VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
VkImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties );
}
void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice,
uint32_t * pQueueFamilyPropertyCount,
VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
}
void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties );
}
void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
uint32_t * pPropertyCount,
VkSparseImageFormatProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
}
void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
{
return ::vkTrimCommandPool( device, commandPool, flags );
}
void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2 * pQueueInfo, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue );
}
VkResult vkCreateSamplerYcbcrConversion( VkDevice device,
const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion );
}
void vkDestroySamplerYcbcrConversion( VkDevice device,
VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator );
}
VkResult vkCreateDescriptorUpdateTemplate( VkDevice device,
const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
}
void vkDestroyDescriptorUpdateTemplate( VkDevice device,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator );
}
void vkUpdateDescriptorSetWithTemplate( VkDevice device,
VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData );
}
void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
VkExternalBufferProperties * pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
}
void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
VkExternalFenceProperties * pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
}
void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
}
void vkGetDescriptorSetLayoutSupport( VkDevice device,
const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
VkDescriptorSetLayoutSupport * pSupport ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport );
}
//=== VK_VERSION_1_2 ===
void vkCmdDrawIndirectCount( VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
}
void vkCmdDrawIndexedIndirectCount( VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawIndexedIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
}
VkResult vkCreateRenderPass2( VkDevice device,
const VkRenderPassCreateInfo2 * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateRenderPass2( device, pCreateInfo, pAllocator, pRenderPass );
}
void vkCmdBeginRenderPass2( VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo * pRenderPassBegin,
const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBeginRenderPass2( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
}
void vkCmdNextSubpass2( VkCommandBuffer commandBuffer,
const VkSubpassBeginInfo * pSubpassBeginInfo,
const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdNextSubpass2( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
}
void vkCmdEndRenderPass2( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdEndRenderPass2( commandBuffer, pSubpassEndInfo );
}
void vkResetQueryPool( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
{
return ::vkResetQueryPool( device, queryPool, firstQuery, queryCount );
}
VkResult vkGetSemaphoreCounterValue( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetSemaphoreCounterValue( device, semaphore, pValue );
}
VkResult vkWaitSemaphores( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
{
return ::vkWaitSemaphores( device, pWaitInfo, timeout );
}
VkResult vkSignalSemaphore( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkSignalSemaphore( device, pSignalInfo );
}
VkDeviceAddress vkGetBufferDeviceAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetBufferDeviceAddress( device, pInfo );
}
uint64_t vkGetBufferOpaqueCaptureAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetBufferOpaqueCaptureAddress( device, pInfo );
}
uint64_t vkGetDeviceMemoryOpaqueCaptureAddress( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceMemoryOpaqueCaptureAddress( device, pInfo );
}
//=== VK_VERSION_1_3 ===
VkResult vkGetPhysicalDeviceToolProperties( VkPhysicalDevice physicalDevice,
uint32_t * pToolCount,
VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceToolProperties( physicalDevice, pToolCount, pToolProperties );
}
VkResult vkCreatePrivateDataSlot( VkDevice device,
const VkPrivateDataSlotCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkPrivateDataSlot * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreatePrivateDataSlot( device, pCreateInfo, pAllocator, pPrivateDataSlot );
}
void vkDestroyPrivateDataSlot( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyPrivateDataSlot( device, privateDataSlot, pAllocator );
}
VkResult vkSetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const
VULKAN_HPP_NOEXCEPT
{
return ::vkSetPrivateData( device, objectType, objectHandle, privateDataSlot, data );
}
void vkGetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const
VULKAN_HPP_NOEXCEPT
{
return ::vkGetPrivateData( device, objectType, objectHandle, privateDataSlot, pData );
}
void vkCmdSetEvent2( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetEvent2( commandBuffer, event, pDependencyInfo );
}
void vkCmdResetEvent2( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdResetEvent2( commandBuffer, event, stageMask );
}
void vkCmdWaitEvents2( VkCommandBuffer commandBuffer,
uint32_t eventCount,
const VkEvent * pEvents,
const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdWaitEvents2( commandBuffer, eventCount, pEvents, pDependencyInfos );
}
void vkCmdPipelineBarrier2( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdPipelineBarrier2( commandBuffer, pDependencyInfo );
}
void vkCmdWriteTimestamp2( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdWriteTimestamp2( commandBuffer, stage, queryPool, query );
}
VkResult vkQueueSubmit2( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
{
return ::vkQueueSubmit2( queue, submitCount, pSubmits, fence );
}
void vkCmdCopyBuffer2( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyBuffer2( commandBuffer, pCopyBufferInfo );
}
void vkCmdCopyImage2( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyImage2( commandBuffer, pCopyImageInfo );
}
void vkCmdCopyBufferToImage2( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyBufferToImage2( commandBuffer, pCopyBufferToImageInfo );
}
void vkCmdCopyImageToBuffer2( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyImageToBuffer2( commandBuffer, pCopyImageToBufferInfo );
}
void vkCmdBlitImage2( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBlitImage2( commandBuffer, pBlitImageInfo );
}
void vkCmdResolveImage2( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdResolveImage2( commandBuffer, pResolveImageInfo );
}
void vkCmdBeginRendering( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBeginRendering( commandBuffer, pRenderingInfo );
}
void vkCmdEndRendering( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdEndRendering( commandBuffer );
}
void vkCmdSetCullMode( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetCullMode( commandBuffer, cullMode );
}
void vkCmdSetFrontFace( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetFrontFace( commandBuffer, frontFace );
}
void vkCmdSetPrimitiveTopology( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetPrimitiveTopology( commandBuffer, primitiveTopology );
}
void vkCmdSetViewportWithCount( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetViewportWithCount( commandBuffer, viewportCount, pViewports );
}
void vkCmdSetScissorWithCount( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetScissorWithCount( commandBuffer, scissorCount, pScissors );
}
void vkCmdBindVertexBuffers2( VkCommandBuffer commandBuffer,
uint32_t firstBinding,
uint32_t bindingCount,
const VkBuffer * pBuffers,
const VkDeviceSize * pOffsets,
const VkDeviceSize * pSizes,
const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindVertexBuffers2( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
}
void vkCmdSetDepthTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthTestEnable( commandBuffer, depthTestEnable );
}
void vkCmdSetDepthWriteEnable( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthWriteEnable( commandBuffer, depthWriteEnable );
}
void vkCmdSetDepthCompareOp( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthCompareOp( commandBuffer, depthCompareOp );
}
void vkCmdSetDepthBoundsTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthBoundsTestEnable( commandBuffer, depthBoundsTestEnable );
}
void vkCmdSetStencilTestEnable( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetStencilTestEnable( commandBuffer, stencilTestEnable );
}
void vkCmdSetStencilOp( VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
VkStencilOp failOp,
VkStencilOp passOp,
VkStencilOp depthFailOp,
VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetStencilOp( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
}
void vkCmdSetRasterizerDiscardEnable( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetRasterizerDiscardEnable( commandBuffer, rasterizerDiscardEnable );
}
void vkCmdSetDepthBiasEnable( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthBiasEnable( commandBuffer, depthBiasEnable );
}
void vkCmdSetPrimitiveRestartEnable( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetPrimitiveRestartEnable( commandBuffer, primitiveRestartEnable );
}
void vkGetDeviceBufferMemoryRequirements( VkDevice device,
const VkDeviceBufferMemoryRequirements * pInfo,
VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceBufferMemoryRequirements( device, pInfo, pMemoryRequirements );
}
void vkGetDeviceImageMemoryRequirements( VkDevice device,
const VkDeviceImageMemoryRequirements * pInfo,
VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceImageMemoryRequirements( device, pInfo, pMemoryRequirements );
}
void vkGetDeviceImageSparseMemoryRequirements( VkDevice device,
const VkDeviceImageMemoryRequirements * pInfo,
uint32_t * pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceImageSparseMemoryRequirements( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
}
//=== VK_KHR_surface ===
void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroySurfaceKHR( instance, surface, pAllocator );
}
VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
VkSurfaceKHR surface,
VkBool32 * pSupported ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported );
}
VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
VkSurfaceCapabilitiesKHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities );
}
VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t * pSurfaceFormatCount,
VkSurfaceFormatKHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats );
}
VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t * pPresentModeCount,
VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes );
}
//=== VK_KHR_swapchain ===
VkResult vkCreateSwapchainKHR( VkDevice device,
const VkSwapchainCreateInfoKHR * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSwapchainKHR * pSwapchain ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain );
}
void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroySwapchainKHR( device, swapchain, pAllocator );
}
VkResult vkGetSwapchainImagesKHR( VkDevice device,
VkSwapchainKHR swapchain,
uint32_t * pSwapchainImageCount,
VkImage * pSwapchainImages ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages );
}
VkResult vkAcquireNextImageKHR(
VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
{
return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex );
}
VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR * pPresentInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkQueuePresentKHR( queue, pPresentInfo );
}
VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice device,
VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities );
}
VkResult
vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes );
}
VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t * pRectCount,
VkRect2D * pRects ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects );
}
VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR * pAcquireInfo, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
{
return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex );
}
//=== VK_KHR_display ===
VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice,
uint32_t * pPropertyCount,
VkDisplayPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
}
VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice,
uint32_t * pPropertyCount,
VkDisplayPlanePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties );
}
VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice,
uint32_t planeIndex,
uint32_t * pDisplayCount,
VkDisplayKHR * pDisplays ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays );
}
VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
uint32_t * pPropertyCount,
VkDisplayModePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties );
}
VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkDisplayModeKHR * pMode ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode );
}
VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice,
VkDisplayModeKHR mode,
uint32_t planeIndex,
VkDisplayPlaneCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities );
}
VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance instance,
const VkDisplaySurfaceCreateInfoKHR * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
}
//=== VK_KHR_display_swapchain ===
VkResult vkCreateSharedSwapchainsKHR( VkDevice device,
uint32_t swapchainCount,
const VkSwapchainCreateInfoKHR * pCreateInfos,
const VkAllocationCallbacks * pAllocator,
VkSwapchainKHR * pSwapchains ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains );
}
# if defined( VK_USE_PLATFORM_XLIB_KHR )
//=== VK_KHR_xlib_surface ===
VkResult vkCreateXlibSurfaceKHR( VkInstance instance,
const VkXlibSurfaceCreateInfoKHR * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
}
VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
Display * dpy,
VisualID visualID ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID );
}
# endif /*VK_USE_PLATFORM_XLIB_KHR*/
# if defined( VK_USE_PLATFORM_XCB_KHR )
//=== VK_KHR_xcb_surface ===
VkResult vkCreateXcbSurfaceKHR( VkInstance instance,
const VkXcbSurfaceCreateInfoKHR * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
}
VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
xcb_connection_t * connection,
xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id );
}
# endif /*VK_USE_PLATFORM_XCB_KHR*/
# if defined( VK_USE_PLATFORM_WAYLAND_KHR )
//=== VK_KHR_wayland_surface ===
VkResult vkCreateWaylandSurfaceKHR( VkInstance instance,
const VkWaylandSurfaceCreateInfoKHR * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
}
VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
struct wl_display * display ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display );
}
# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
# if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_KHR_android_surface ===
VkResult vkCreateAndroidSurfaceKHR( VkInstance instance,
const VkAndroidSurfaceCreateInfoKHR * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
}
# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
# if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_win32_surface ===
VkResult vkCreateWin32SurfaceKHR( VkInstance instance,
const VkWin32SurfaceCreateInfoKHR * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
}
VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex );
}
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_debug_report ===
VkResult vkCreateDebugReportCallbackEXT( VkInstance instance,
const VkDebugReportCallbackCreateInfoEXT * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkDebugReportCallbackEXT * pCallback ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback );
}
void vkDestroyDebugReportCallbackEXT( VkInstance instance,
VkDebugReportCallbackEXT callback,
const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator );
}
void vkDebugReportMessageEXT( VkInstance instance,
VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objectType,
uint64_t object,
size_t location,
int32_t messageCode,
const char * pLayerPrefix,
const char * pMessage ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage );
}
//=== VK_EXT_debug_marker ===
VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo );
}
VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo );
}
void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo );
}
void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDebugMarkerEndEXT( commandBuffer );
}
void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo );
}
//=== VK_KHR_video_queue ===
VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR( VkPhysicalDevice physicalDevice,
const VkVideoProfileInfoKHR * pVideoProfile,
VkVideoCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceVideoCapabilitiesKHR( physicalDevice, pVideoProfile, pCapabilities );
}
VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR( VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
uint32_t * pVideoFormatPropertyCount,
VkVideoFormatPropertiesKHR * pVideoFormatProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceVideoFormatPropertiesKHR( physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties );
}
VkResult vkCreateVideoSessionKHR( VkDevice device,
const VkVideoSessionCreateInfoKHR * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkVideoSessionKHR * pVideoSession ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateVideoSessionKHR( device, pCreateInfo, pAllocator, pVideoSession );
}
void vkDestroyVideoSessionKHR( VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyVideoSessionKHR( device, videoSession, pAllocator );
}
VkResult vkGetVideoSessionMemoryRequirementsKHR( VkDevice device,
VkVideoSessionKHR videoSession,
uint32_t * pMemoryRequirementsCount,
VkVideoSessionMemoryRequirementsKHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetVideoSessionMemoryRequirementsKHR( device, videoSession, pMemoryRequirementsCount, pMemoryRequirements );
}
VkResult vkBindVideoSessionMemoryKHR( VkDevice device,
VkVideoSessionKHR videoSession,
uint32_t bindSessionMemoryInfoCount,
const VkBindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos ) const VULKAN_HPP_NOEXCEPT
{
return ::vkBindVideoSessionMemoryKHR( device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos );
}
VkResult vkCreateVideoSessionParametersKHR( VkDevice device,
const VkVideoSessionParametersCreateInfoKHR * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkVideoSessionParametersKHR * pVideoSessionParameters ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateVideoSessionParametersKHR( device, pCreateInfo, pAllocator, pVideoSessionParameters );
}
VkResult vkUpdateVideoSessionParametersKHR( VkDevice device,
VkVideoSessionParametersKHR videoSessionParameters,
const VkVideoSessionParametersUpdateInfoKHR * pUpdateInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkUpdateVideoSessionParametersKHR( device, videoSessionParameters, pUpdateInfo );
}
void vkDestroyVideoSessionParametersKHR( VkDevice device,
VkVideoSessionParametersKHR videoSessionParameters,
const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyVideoSessionParametersKHR( device, videoSessionParameters, pAllocator );
}
void vkCmdBeginVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBeginVideoCodingKHR( commandBuffer, pBeginInfo );
}
void vkCmdEndVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR * pEndCodingInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdEndVideoCodingKHR( commandBuffer, pEndCodingInfo );
}
void vkCmdControlVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR * pCodingControlInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdControlVideoCodingKHR( commandBuffer, pCodingControlInfo );
}
//=== VK_KHR_video_decode_queue ===
void vkCmdDecodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR * pDecodeInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDecodeVideoKHR( commandBuffer, pDecodeInfo );
}
//=== VK_EXT_transform_feedback ===
void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer,
uint32_t firstBinding,
uint32_t bindingCount,
const VkBuffer * pBuffers,
const VkDeviceSize * pOffsets,
const VkDeviceSize * pSizes ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes );
}
void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer,
uint32_t firstCounterBuffer,
uint32_t counterBufferCount,
const VkBuffer * pCounterBuffers,
const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
}
void vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer,
uint32_t firstCounterBuffer,
uint32_t counterBufferCount,
const VkBuffer * pCounterBuffers,
const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
}
void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index ) const
VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index );
}
void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index );
}
void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer,
uint32_t instanceCount,
uint32_t firstInstance,
VkBuffer counterBuffer,
VkDeviceSize counterBufferOffset,
uint32_t counterOffset,
uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride );
}
//=== VK_NVX_binary_import ===
VkResult vkCreateCuModuleNVX( VkDevice device,
const VkCuModuleCreateInfoNVX * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkCuModuleNVX * pModule ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateCuModuleNVX( device, pCreateInfo, pAllocator, pModule );
}
VkResult vkCreateCuFunctionNVX( VkDevice device,
const VkCuFunctionCreateInfoNVX * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkCuFunctionNVX * pFunction ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateCuFunctionNVX( device, pCreateInfo, pAllocator, pFunction );
}
void vkDestroyCuModuleNVX( VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyCuModuleNVX( device, module, pAllocator );
}
void vkDestroyCuFunctionNVX( VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyCuFunctionNVX( device, function, pAllocator );
}
void vkCmdCuLaunchKernelNVX( VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCuLaunchKernelNVX( commandBuffer, pLaunchInfo );
}
//=== VK_NVX_image_view_handle ===
uint32_t vkGetImageViewHandleNVX( VkDevice device, const VkImageViewHandleInfoNVX * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageViewHandleNVX( device, pInfo );
}
VkResult vkGetImageViewAddressNVX( VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageViewAddressNVX( device, imageView, pProperties );
}
//=== VK_AMD_draw_indirect_count ===
void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
}
void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
}
//=== VK_AMD_shader_info ===
VkResult vkGetShaderInfoAMD( VkDevice device,
VkPipeline pipeline,
VkShaderStageFlagBits shaderStage,
VkShaderInfoTypeAMD infoType,
size_t * pInfoSize,
void * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo );
}
//=== VK_KHR_dynamic_rendering ===
void vkCmdBeginRenderingKHR( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBeginRenderingKHR( commandBuffer, pRenderingInfo );
}
void vkCmdEndRenderingKHR( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdEndRenderingKHR( commandBuffer );
}
# if defined( VK_USE_PLATFORM_GGP )
//=== VK_GGP_stream_descriptor_surface ===
VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance instance,
const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateStreamDescriptorSurfaceGGP( instance, pCreateInfo, pAllocator, pSurface );
}
# endif /*VK_USE_PLATFORM_GGP*/
//=== VK_NV_external_memory_capabilities ===
VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
VkImageTiling tiling,
VkImageUsageFlags usage,
VkImageCreateFlags flags,
VkExternalMemoryHandleTypeFlagsNV externalHandleType,
VkExternalImageFormatPropertiesNV * pExternalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties );
}
# if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_external_memory_win32 ===
VkResult vkGetMemoryWin32HandleNV( VkDevice device,
VkDeviceMemory memory,
VkExternalMemoryHandleTypeFlagsNV handleType,
HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle );
}
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_get_physical_device_properties2 ===
void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures );
}
void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties );
}
void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties );
}
VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
VkImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties );
}
void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice,
uint32_t * pQueueFamilyPropertyCount,
VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
}
void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties );
}
void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
uint32_t * pPropertyCount,
VkSparseImageFormatProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
}
//=== VK_KHR_device_group ===
void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device,
uint32_t heapIndex,
uint32_t localDeviceIndex,
uint32_t remoteDeviceIndex,
VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
}
void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask );
}
void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer,
uint32_t baseGroupX,
uint32_t baseGroupY,
uint32_t baseGroupZ,
uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
}
# if defined( VK_USE_PLATFORM_VI_NN )
//=== VK_NN_vi_surface ===
VkResult vkCreateViSurfaceNN( VkInstance instance,
const VkViSurfaceCreateInfoNN * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface );
}
# endif /*VK_USE_PLATFORM_VI_NN*/
//=== VK_KHR_maintenance1 ===
void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
{
return ::vkTrimCommandPoolKHR( device, commandPool, flags );
}
//=== VK_KHR_device_group_creation ===
VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance instance,
uint32_t * pPhysicalDeviceGroupCount,
VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
}
//=== VK_KHR_external_memory_capabilities ===
void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
VkExternalBufferProperties * pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
}
# if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_memory_win32 ===
VkResult vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
}
VkResult vkGetMemoryWin32HandlePropertiesKHR( VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
HANDLE handle,
VkMemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties );
}
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_memory_fd ===
VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd );
}
VkResult vkGetMemoryFdPropertiesKHR( VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
int fd,
VkMemoryFdPropertiesKHR * pMemoryFdProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties );
}
//=== VK_KHR_external_semaphore_capabilities ===
void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
}
# if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_semaphore_win32 ===
VkResult vkImportSemaphoreWin32HandleKHR( VkDevice device,
const VkImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo );
}
VkResult
vkGetSemaphoreWin32HandleKHR( VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
}
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_semaphore_fd ===
VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo );
}
VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd );
}
//=== VK_KHR_push_descriptor ===
void vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
uint32_t set,
uint32_t descriptorWriteCount,
const VkWriteDescriptorSet * pDescriptorWrites ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites );
}
void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
VkPipelineLayout layout,
uint32_t set,
const void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData );
}
//=== VK_EXT_conditional_rendering ===
void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer commandBuffer,
const VkConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin );
}
void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdEndConditionalRenderingEXT( commandBuffer );
}
//=== VK_KHR_descriptor_update_template ===
VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice device,
const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
}
void vkDestroyDescriptorUpdateTemplateKHR( VkDevice device,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator );
}
void vkUpdateDescriptorSetWithTemplateKHR( VkDevice device,
VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData );
}
//=== VK_NV_clip_space_w_scaling ===
void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer,
uint32_t firstViewport,
uint32_t viewportCount,
const VkViewportWScalingNV * pViewportWScalings ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings );
}
//=== VK_EXT_direct_mode_display ===
VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
{
return ::vkReleaseDisplayEXT( physicalDevice, display );
}
# if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
//=== VK_EXT_acquire_xlib_display ===
VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
{
return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display );
}
VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, RROutput rrOutput, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay );
}
# endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
//=== VK_EXT_display_surface_counter ===
VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
VkSurfaceCapabilities2EXT * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities );
}
//=== VK_EXT_display_control ===
VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT * pDisplayPowerInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo );
}
VkResult vkRegisterDeviceEventEXT( VkDevice device,
const VkDeviceEventInfoEXT * pDeviceEventInfo,
const VkAllocationCallbacks * pAllocator,
VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
{
return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence );
}
VkResult vkRegisterDisplayEventEXT( VkDevice device,
VkDisplayKHR display,
const VkDisplayEventInfoEXT * pDisplayEventInfo,
const VkAllocationCallbacks * pAllocator,
VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
{
return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence );
}
VkResult vkGetSwapchainCounterEXT( VkDevice device,
VkSwapchainKHR swapchain,
VkSurfaceCounterFlagBitsEXT counter,
uint64_t * pCounterValue ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue );
}
//=== VK_GOOGLE_display_timing ===
VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device,
VkSwapchainKHR swapchain,
VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties );
}
VkResult vkGetPastPresentationTimingGOOGLE( VkDevice device,
VkSwapchainKHR swapchain,
uint32_t * pPresentationTimingCount,
VkPastPresentationTimingGOOGLE * pPresentationTimings ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings );
}
//=== VK_EXT_discard_rectangles ===
void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer,
uint32_t firstDiscardRectangle,
uint32_t discardRectangleCount,
const VkRect2D * pDiscardRectangles ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles );
}
void vkCmdSetDiscardRectangleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDiscardRectangleEnableEXT( commandBuffer, discardRectangleEnable );
}
void vkCmdSetDiscardRectangleModeEXT( VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDiscardRectangleModeEXT( commandBuffer, discardRectangleMode );
}
//=== VK_EXT_hdr_metadata ===
void vkSetHdrMetadataEXT( VkDevice device,
uint32_t swapchainCount,
const VkSwapchainKHR * pSwapchains,
const VkHdrMetadataEXT * pMetadata ) const VULKAN_HPP_NOEXCEPT
{
return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata );
}
//=== VK_KHR_create_renderpass2 ===
VkResult vkCreateRenderPass2KHR( VkDevice device,
const VkRenderPassCreateInfo2 * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass );
}
void vkCmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo * pRenderPassBegin,
const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
}
void vkCmdNextSubpass2KHR( VkCommandBuffer commandBuffer,
const VkSubpassBeginInfo * pSubpassBeginInfo,
const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
}
void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo );
}
//=== VK_KHR_shared_presentable_image ===
VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetSwapchainStatusKHR( device, swapchain );
}
//=== VK_KHR_external_fence_capabilities ===
void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
VkExternalFenceProperties * pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
}
# if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_fence_win32 ===
VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo );
}
VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
}
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_fence_fd ===
VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkImportFenceFdKHR( device, pImportFenceFdInfo );
}
VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd );
}
//=== VK_KHR_performance_query ===
VkResult
vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
uint32_t * pCounterCount,
VkPerformanceCounterKHR * pCounters,
VkPerformanceCounterDescriptionKHR * pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT
{
return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions );
}
void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( VkPhysicalDevice physicalDevice,
const VkQueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
uint32_t * pNumPasses ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( physicalDevice, pPerformanceQueryCreateInfo, pNumPasses );
}
VkResult vkAcquireProfilingLockKHR( VkDevice device, const VkAcquireProfilingLockInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkAcquireProfilingLockKHR( device, pInfo );
}
void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT
{
return ::vkReleaseProfilingLockKHR( device );
}
//=== VK_KHR_get_surface_capabilities2 ===
VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
VkSurfaceCapabilities2KHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities );
}
VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
uint32_t * pSurfaceFormatCount,
VkSurfaceFormat2KHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats );
}
//=== VK_KHR_get_display_properties2 ===
VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice,
uint32_t * pPropertyCount,
VkDisplayProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties );
}
VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice,
uint32_t * pPropertyCount,
VkDisplayPlaneProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties );
}
VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
uint32_t * pPropertyCount,
VkDisplayModeProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties );
}
VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice,
const VkDisplayPlaneInfo2KHR * pDisplayPlaneInfo,
VkDisplayPlaneCapabilities2KHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities );
}
# if defined( VK_USE_PLATFORM_IOS_MVK )
//=== VK_MVK_ios_surface ===
VkResult vkCreateIOSSurfaceMVK( VkInstance instance,
const VkIOSSurfaceCreateInfoMVK * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
}
# endif /*VK_USE_PLATFORM_IOS_MVK*/
# if defined( VK_USE_PLATFORM_MACOS_MVK )
//=== VK_MVK_macos_surface ===
VkResult vkCreateMacOSSurfaceMVK( VkInstance instance,
const VkMacOSSurfaceCreateInfoMVK * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
}
# endif /*VK_USE_PLATFORM_MACOS_MVK*/
//=== VK_EXT_debug_utils ===
VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo );
}
VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo );
}
void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo );
}
void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
{
return ::vkQueueEndDebugUtilsLabelEXT( queue );
}
void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo );
}
void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
}
void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer );
}
void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
}
VkResult vkCreateDebugUtilsMessengerEXT( VkInstance instance,
const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkDebugUtilsMessengerEXT * pMessenger ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger );
}
void vkDestroyDebugUtilsMessengerEXT( VkInstance instance,
VkDebugUtilsMessengerEXT messenger,
const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator );
}
void vkSubmitDebugUtilsMessageEXT( VkInstance instance,
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
VkDebugUtilsMessageTypeFlagsEXT messageTypes,
const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData );
}
# if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_ANDROID_external_memory_android_hardware_buffer ===
VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device,
const struct AHardwareBuffer * buffer,
VkAndroidHardwareBufferPropertiesANDROID * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties );
}
VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device,
const VkMemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
struct AHardwareBuffer ** pBuffer ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer );
}
# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
# if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_shader_enqueue ===
VkResult vkCreateExecutionGraphPipelinesAMDX( VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkExecutionGraphPipelineCreateInfoAMDX * pCreateInfos,
const VkAllocationCallbacks * pAllocator,
VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateExecutionGraphPipelinesAMDX( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
}
VkResult vkGetExecutionGraphPipelineScratchSizeAMDX( VkDevice device,
VkPipeline executionGraph,
VkExecutionGraphPipelineScratchSizeAMDX * pSizeInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetExecutionGraphPipelineScratchSizeAMDX( device, executionGraph, pSizeInfo );
}
VkResult vkGetExecutionGraphPipelineNodeIndexAMDX( VkDevice device,
VkPipeline executionGraph,
const VkPipelineShaderStageNodeCreateInfoAMDX * pNodeInfo,
uint32_t * pNodeIndex ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetExecutionGraphPipelineNodeIndexAMDX( device, executionGraph, pNodeInfo, pNodeIndex );
}
void vkCmdInitializeGraphScratchMemoryAMDX( VkCommandBuffer commandBuffer, VkDeviceAddress scratch ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdInitializeGraphScratchMemoryAMDX( commandBuffer, scratch );
}
void vkCmdDispatchGraphAMDX( VkCommandBuffer commandBuffer,
VkDeviceAddress scratch,
const VkDispatchGraphCountInfoAMDX * pCountInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDispatchGraphAMDX( commandBuffer, scratch, pCountInfo );
}
void vkCmdDispatchGraphIndirectAMDX( VkCommandBuffer commandBuffer,
VkDeviceAddress scratch,
const VkDispatchGraphCountInfoAMDX * pCountInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDispatchGraphIndirectAMDX( commandBuffer, scratch, pCountInfo );
}
void vkCmdDispatchGraphIndirectCountAMDX( VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceAddress countInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDispatchGraphIndirectCountAMDX( commandBuffer, scratch, countInfo );
}
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_sample_locations ===
void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT * pSampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo );
}
void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice,
VkSampleCountFlagBits samples,
VkMultisamplePropertiesEXT * pMultisampleProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties );
}
//=== VK_KHR_get_memory_requirements2 ===
void vkGetImageMemoryRequirements2KHR( VkDevice device,
const VkImageMemoryRequirementsInfo2 * pInfo,
VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
}
void vkGetBufferMemoryRequirements2KHR( VkDevice device,
const VkBufferMemoryRequirementsInfo2 * pInfo,
VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
}
void vkGetImageSparseMemoryRequirements2KHR( VkDevice device,
const VkImageSparseMemoryRequirementsInfo2 * pInfo,
uint32_t * pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
}
//=== VK_KHR_acceleration_structure ===
VkResult vkCreateAccelerationStructureKHR( VkDevice device,
const VkAccelerationStructureCreateInfoKHR * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkAccelerationStructureKHR * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateAccelerationStructureKHR( device, pCreateInfo, pAllocator, pAccelerationStructure );
}
void vkDestroyAccelerationStructureKHR( VkDevice device,
VkAccelerationStructureKHR accelerationStructure,
const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyAccelerationStructureKHR( device, accelerationStructure, pAllocator );
}
void vkCmdBuildAccelerationStructuresKHR( VkCommandBuffer commandBuffer,
uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,
const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBuildAccelerationStructuresKHR( commandBuffer, infoCount, pInfos, ppBuildRangeInfos );
}
void vkCmdBuildAccelerationStructuresIndirectKHR( VkCommandBuffer commandBuffer,
uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,
const VkDeviceAddress * pIndirectDeviceAddresses,
const uint32_t * pIndirectStrides,
const uint32_t * const * ppMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBuildAccelerationStructuresIndirectKHR(
commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts );
}
VkResult vkBuildAccelerationStructuresKHR( VkDevice device,
VkDeferredOperationKHR deferredOperation,
uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,
const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
{
return ::vkBuildAccelerationStructuresKHR( device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos );
}
VkResult vkCopyAccelerationStructureKHR( VkDevice device,
VkDeferredOperationKHR deferredOperation,
const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCopyAccelerationStructureKHR( device, deferredOperation, pInfo );
}
VkResult vkCopyAccelerationStructureToMemoryKHR( VkDevice device,
VkDeferredOperationKHR deferredOperation,
const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCopyAccelerationStructureToMemoryKHR( device, deferredOperation, pInfo );
}
VkResult vkCopyMemoryToAccelerationStructureKHR( VkDevice device,
VkDeferredOperationKHR deferredOperation,
const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCopyMemoryToAccelerationStructureKHR( device, deferredOperation, pInfo );
}
VkResult vkWriteAccelerationStructuresPropertiesKHR( VkDevice device,
uint32_t accelerationStructureCount,
const VkAccelerationStructureKHR * pAccelerationStructures,
VkQueryType queryType,
size_t dataSize,
void * pData,
size_t stride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkWriteAccelerationStructuresPropertiesKHR( device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride );
}
void vkCmdCopyAccelerationStructureKHR( VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyAccelerationStructureKHR( commandBuffer, pInfo );
}
void vkCmdCopyAccelerationStructureToMemoryKHR( VkCommandBuffer commandBuffer,
const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyAccelerationStructureToMemoryKHR( commandBuffer, pInfo );
}
void vkCmdCopyMemoryToAccelerationStructureKHR( VkCommandBuffer commandBuffer,
const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyMemoryToAccelerationStructureKHR( commandBuffer, pInfo );
}
VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR( VkDevice device,
const VkAccelerationStructureDeviceAddressInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetAccelerationStructureDeviceAddressKHR( device, pInfo );
}
void vkCmdWriteAccelerationStructuresPropertiesKHR( VkCommandBuffer commandBuffer,
uint32_t accelerationStructureCount,
const VkAccelerationStructureKHR * pAccelerationStructures,
VkQueryType queryType,
VkQueryPool queryPool,
uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdWriteAccelerationStructuresPropertiesKHR(
commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
}
void vkGetDeviceAccelerationStructureCompatibilityKHR( VkDevice device,
const VkAccelerationStructureVersionInfoKHR * pVersionInfo,
VkAccelerationStructureCompatibilityKHR * pCompatibility ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceAccelerationStructureCompatibilityKHR( device, pVersionInfo, pCompatibility );
}
void vkGetAccelerationStructureBuildSizesKHR( VkDevice device,
VkAccelerationStructureBuildTypeKHR buildType,
const VkAccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
const uint32_t * pMaxPrimitiveCounts,
VkAccelerationStructureBuildSizesInfoKHR * pSizeInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetAccelerationStructureBuildSizesKHR( device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo );
}
//=== VK_KHR_ray_tracing_pipeline ===
void vkCmdTraceRaysKHR( VkCommandBuffer commandBuffer,
const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
uint32_t width,
uint32_t height,
uint32_t depth ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdTraceRaysKHR(
commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth );
}
VkResult vkCreateRayTracingPipelinesKHR( VkDevice device,
VkDeferredOperationKHR deferredOperation,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkRayTracingPipelineCreateInfoKHR * pCreateInfos,
const VkAllocationCallbacks * pAllocator,
VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateRayTracingPipelinesKHR( device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
}
VkResult vkGetRayTracingShaderGroupHandlesKHR(
VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetRayTracingShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
}
VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
}
void vkCmdTraceRaysIndirectKHR( VkCommandBuffer commandBuffer,
const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdTraceRaysIndirectKHR(
commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress );
}
VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR( VkDevice device,
VkPipeline pipeline,
uint32_t group,
VkShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetRayTracingShaderGroupStackSizeKHR( device, pipeline, group, groupShader );
}
void vkCmdSetRayTracingPipelineStackSizeKHR( VkCommandBuffer commandBuffer, uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetRayTracingPipelineStackSizeKHR( commandBuffer, pipelineStackSize );
}
//=== VK_KHR_sampler_ycbcr_conversion ===
VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice device,
const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion );
}
void vkDestroySamplerYcbcrConversionKHR( VkDevice device,
VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator );
}
//=== VK_KHR_bind_memory2 ===
VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
{
return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos );
}
VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
{
return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos );
}
//=== VK_EXT_image_drm_format_modifier ===
VkResult
vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties );
}
//=== VK_EXT_validation_cache ===
VkResult vkCreateValidationCacheEXT( VkDevice device,
const VkValidationCacheCreateInfoEXT * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkValidationCacheEXT * pValidationCache ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache );
}
void
vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator );
}
VkResult vkMergeValidationCachesEXT( VkDevice device,
VkValidationCacheEXT dstCache,
uint32_t srcCacheCount,
const VkValidationCacheEXT * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
{
return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches );
}
VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData );
}
//=== VK_NV_shading_rate_image ===
void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout );
}
void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer,
uint32_t firstViewport,
uint32_t viewportCount,
const VkShadingRatePaletteNV * pShadingRatePalettes ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes );
}
void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer,
VkCoarseSampleOrderTypeNV sampleOrderType,
uint32_t customSampleOrderCount,
const VkCoarseSampleOrderCustomNV * pCustomSampleOrders ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders );
}
//=== VK_NV_ray_tracing ===
VkResult vkCreateAccelerationStructureNV( VkDevice device,
const VkAccelerationStructureCreateInfoNV * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkAccelerationStructureNV * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure );
}
void vkDestroyAccelerationStructureNV( VkDevice device,
VkAccelerationStructureNV accelerationStructure,
const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator );
}
void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device,
const VkAccelerationStructureMemoryRequirementsInfoNV * pInfo,
VkMemoryRequirements2KHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
}
VkResult vkBindAccelerationStructureMemoryNV( VkDevice device,
uint32_t bindInfoCount,
const VkBindAccelerationStructureMemoryInfoNV * pBindInfos ) const VULKAN_HPP_NOEXCEPT
{
return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos );
}
void vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer,
const VkAccelerationStructureInfoNV * pInfo,
VkBuffer instanceData,
VkDeviceSize instanceOffset,
VkBool32 update,
VkAccelerationStructureNV dst,
VkAccelerationStructureNV src,
VkBuffer scratch,
VkDeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset );
}
void vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer,
VkAccelerationStructureNV dst,
VkAccelerationStructureNV src,
VkCopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode );
}
void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer,
VkBuffer raygenShaderBindingTableBuffer,
VkDeviceSize raygenShaderBindingOffset,
VkBuffer missShaderBindingTableBuffer,
VkDeviceSize missShaderBindingOffset,
VkDeviceSize missShaderBindingStride,
VkBuffer hitShaderBindingTableBuffer,
VkDeviceSize hitShaderBindingOffset,
VkDeviceSize hitShaderBindingStride,
VkBuffer callableShaderBindingTableBuffer,
VkDeviceSize callableShaderBindingOffset,
VkDeviceSize callableShaderBindingStride,
uint32_t width,
uint32_t height,
uint32_t depth ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdTraceRaysNV( commandBuffer,
raygenShaderBindingTableBuffer,
raygenShaderBindingOffset,
missShaderBindingTableBuffer,
missShaderBindingOffset,
missShaderBindingStride,
hitShaderBindingTableBuffer,
hitShaderBindingOffset,
hitShaderBindingStride,
callableShaderBindingTableBuffer,
callableShaderBindingOffset,
callableShaderBindingStride,
width,
height,
depth );
}
VkResult vkCreateRayTracingPipelinesNV( VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkRayTracingPipelineCreateInfoNV * pCreateInfos,
const VkAllocationCallbacks * pAllocator,
VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
}
VkResult vkGetRayTracingShaderGroupHandlesNV(
VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData );
}
VkResult vkGetAccelerationStructureHandleNV( VkDevice device,
VkAccelerationStructureNV accelerationStructure,
size_t dataSize,
void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData );
}
void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer,
uint32_t accelerationStructureCount,
const VkAccelerationStructureNV * pAccelerationStructures,
VkQueryType queryType,
VkQueryPool queryPool,
uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdWriteAccelerationStructuresPropertiesNV(
commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
}
VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCompileDeferredNV( device, pipeline, shader );
}
//=== VK_KHR_maintenance3 ===
void vkGetDescriptorSetLayoutSupportKHR( VkDevice device,
const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
VkDescriptorSetLayoutSupport * pSupport ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport );
}
//=== VK_KHR_draw_indirect_count ===
void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
}
void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
}
//=== VK_EXT_external_memory_host ===
VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
const void * pHostPointer,
VkMemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties );
}
//=== VK_AMD_buffer_marker ===
void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
uint32_t marker ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker );
}
//=== VK_EXT_calibrated_timestamps ===
VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice,
uint32_t * pTimeDomainCount,
VkTimeDomainKHR * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains );
}
VkResult vkGetCalibratedTimestampsEXT( VkDevice device,
uint32_t timestampCount,
const VkCalibratedTimestampInfoKHR * pTimestampInfos,
uint64_t * pTimestamps,
uint64_t * pMaxDeviation ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
}
//=== VK_NV_mesh_shader ===
void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask );
}
void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride );
}
void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
}
//=== VK_NV_scissor_exclusive ===
void vkCmdSetExclusiveScissorEnableNV( VkCommandBuffer commandBuffer,
uint32_t firstExclusiveScissor,
uint32_t exclusiveScissorCount,
const VkBool32 * pExclusiveScissorEnables ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetExclusiveScissorEnableNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables );
}
void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer,
uint32_t firstExclusiveScissor,
uint32_t exclusiveScissorCount,
const VkRect2D * pExclusiveScissors ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors );
}
//=== VK_NV_device_diagnostic_checkpoints ===
void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker );
}
void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointDataNV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData );
}
//=== VK_KHR_timeline_semaphore ===
VkResult vkGetSemaphoreCounterValueKHR( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetSemaphoreCounterValueKHR( device, semaphore, pValue );
}
VkResult vkWaitSemaphoresKHR( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
{
return ::vkWaitSemaphoresKHR( device, pWaitInfo, timeout );
}
VkResult vkSignalSemaphoreKHR( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkSignalSemaphoreKHR( device, pSignalInfo );
}
//=== VK_INTEL_performance_query ===
VkResult vkInitializePerformanceApiINTEL( VkDevice device, const VkInitializePerformanceApiInfoINTEL * pInitializeInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkInitializePerformanceApiINTEL( device, pInitializeInfo );
}
void vkUninitializePerformanceApiINTEL( VkDevice device ) const VULKAN_HPP_NOEXCEPT
{
return ::vkUninitializePerformanceApiINTEL( device );
}
VkResult vkCmdSetPerformanceMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetPerformanceMarkerINTEL( commandBuffer, pMarkerInfo );
}
VkResult vkCmdSetPerformanceStreamMarkerINTEL( VkCommandBuffer commandBuffer,
const VkPerformanceStreamMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetPerformanceStreamMarkerINTEL( commandBuffer, pMarkerInfo );
}
VkResult vkCmdSetPerformanceOverrideINTEL( VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL * pOverrideInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetPerformanceOverrideINTEL( commandBuffer, pOverrideInfo );
}
VkResult vkAcquirePerformanceConfigurationINTEL( VkDevice device,
const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
VkPerformanceConfigurationINTEL * pConfiguration ) const VULKAN_HPP_NOEXCEPT
{
return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration );
}
VkResult vkReleasePerformanceConfigurationINTEL( VkDevice device, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
{
return ::vkReleasePerformanceConfigurationINTEL( device, configuration );
}
VkResult vkQueueSetPerformanceConfigurationINTEL( VkQueue queue, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
{
return ::vkQueueSetPerformanceConfigurationINTEL( queue, configuration );
}
VkResult
vkGetPerformanceParameterINTEL( VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL * pValue ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPerformanceParameterINTEL( device, parameter, pValue );
}
//=== VK_AMD_display_native_hdr ===
void vkSetLocalDimmingAMD( VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkSetLocalDimmingAMD( device, swapChain, localDimmingEnable );
}
# if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_imagepipe_surface ===
VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance,
const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface );
}
# endif /*VK_USE_PLATFORM_FUCHSIA*/
# if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_surface ===
VkResult vkCreateMetalSurfaceEXT( VkInstance instance,
const VkMetalSurfaceCreateInfoEXT * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateMetalSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
}
# endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_fragment_shading_rate ===
VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR( VkPhysicalDevice physicalDevice,
uint32_t * pFragmentShadingRateCount,
VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceFragmentShadingRatesKHR( physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates );
}
void vkCmdSetFragmentShadingRateKHR( VkCommandBuffer commandBuffer,
const VkExtent2D * pFragmentSize,
const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetFragmentShadingRateKHR( commandBuffer, pFragmentSize, combinerOps );
}
//=== VK_KHR_dynamic_rendering_local_read ===
void vkCmdSetRenderingAttachmentLocationsKHR( VkCommandBuffer commandBuffer,
const VkRenderingAttachmentLocationInfoKHR * pLocationInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetRenderingAttachmentLocationsKHR( commandBuffer, pLocationInfo );
}
void vkCmdSetRenderingInputAttachmentIndicesKHR( VkCommandBuffer commandBuffer,
const VkRenderingInputAttachmentIndexInfoKHR * pInputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetRenderingInputAttachmentIndicesKHR( commandBuffer, pInputAttachmentIndexInfo );
}
//=== VK_EXT_buffer_device_address ===
VkDeviceAddress vkGetBufferDeviceAddressEXT( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetBufferDeviceAddressEXT( device, pInfo );
}
//=== VK_EXT_tooling_info ===
VkResult vkGetPhysicalDeviceToolPropertiesEXT( VkPhysicalDevice physicalDevice,
uint32_t * pToolCount,
VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceToolPropertiesEXT( physicalDevice, pToolCount, pToolProperties );
}
//=== VK_KHR_present_wait ===
VkResult vkWaitForPresentKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
{
return ::vkWaitForPresentKHR( device, swapchain, presentId, timeout );
}
//=== VK_NV_cooperative_matrix ===
VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDevice physicalDevice,
uint32_t * pPropertyCount,
VkCooperativeMatrixPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( physicalDevice, pPropertyCount, pProperties );
}
//=== VK_NV_coverage_reduction_mode ===
VkResult your_sha256_hashV(
VkPhysicalDevice physicalDevice, uint32_t * pCombinationCount, VkFramebufferMixedSamplesCombinationNV * pCombinations ) const VULKAN_HPP_NOEXCEPT
{
return ::your_sha256_hashV( physicalDevice, pCombinationCount, pCombinations );
}
# if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_EXT_full_screen_exclusive ===
VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
uint32_t * pPresentModeCount,
VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceSurfacePresentModes2EXT( physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes );
}
VkResult vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
{
return ::vkAcquireFullScreenExclusiveModeEXT( device, swapchain );
}
VkResult vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
{
return ::vkReleaseFullScreenExclusiveModeEXT( device, swapchain );
}
VkResult vkGetDeviceGroupSurfacePresentModes2EXT( VkDevice device,
const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceGroupSurfacePresentModes2EXT( device, pSurfaceInfo, pModes );
}
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_headless_surface ===
VkResult vkCreateHeadlessSurfaceEXT( VkInstance instance,
const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateHeadlessSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
}
//=== VK_KHR_buffer_device_address ===
VkDeviceAddress vkGetBufferDeviceAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetBufferDeviceAddressKHR( device, pInfo );
}
uint64_t vkGetBufferOpaqueCaptureAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetBufferOpaqueCaptureAddressKHR( device, pInfo );
}
uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceMemoryOpaqueCaptureAddressKHR( device, pInfo );
}
//=== VK_EXT_line_rasterization ===
void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetLineStippleEXT( commandBuffer, lineStippleFactor, lineStipplePattern );
}
//=== VK_EXT_host_query_reset ===
void vkResetQueryPoolEXT( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
{
return ::vkResetQueryPoolEXT( device, queryPool, firstQuery, queryCount );
}
//=== VK_EXT_extended_dynamic_state ===
void vkCmdSetCullModeEXT( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetCullModeEXT( commandBuffer, cullMode );
}
void vkCmdSetFrontFaceEXT( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetFrontFaceEXT( commandBuffer, frontFace );
}
void vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetPrimitiveTopologyEXT( commandBuffer, primitiveTopology );
}
void vkCmdSetViewportWithCountEXT( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetViewportWithCountEXT( commandBuffer, viewportCount, pViewports );
}
void vkCmdSetScissorWithCountEXT( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetScissorWithCountEXT( commandBuffer, scissorCount, pScissors );
}
void vkCmdBindVertexBuffers2EXT( VkCommandBuffer commandBuffer,
uint32_t firstBinding,
uint32_t bindingCount,
const VkBuffer * pBuffers,
const VkDeviceSize * pOffsets,
const VkDeviceSize * pSizes,
const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindVertexBuffers2EXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
}
void vkCmdSetDepthTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthTestEnableEXT( commandBuffer, depthTestEnable );
}
void vkCmdSetDepthWriteEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthWriteEnableEXT( commandBuffer, depthWriteEnable );
}
void vkCmdSetDepthCompareOpEXT( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthCompareOpEXT( commandBuffer, depthCompareOp );
}
void vkCmdSetDepthBoundsTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthBoundsTestEnableEXT( commandBuffer, depthBoundsTestEnable );
}
void vkCmdSetStencilTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetStencilTestEnableEXT( commandBuffer, stencilTestEnable );
}
void vkCmdSetStencilOpEXT( VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
VkStencilOp failOp,
VkStencilOp passOp,
VkStencilOp depthFailOp,
VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetStencilOpEXT( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
}
//=== VK_KHR_deferred_host_operations ===
VkResult vkCreateDeferredOperationKHR( VkDevice device,
const VkAllocationCallbacks * pAllocator,
VkDeferredOperationKHR * pDeferredOperation ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateDeferredOperationKHR( device, pAllocator, pDeferredOperation );
}
void vkDestroyDeferredOperationKHR( VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyDeferredOperationKHR( device, operation, pAllocator );
}
uint32_t vkGetDeferredOperationMaxConcurrencyKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeferredOperationMaxConcurrencyKHR( device, operation );
}
VkResult vkGetDeferredOperationResultKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeferredOperationResultKHR( device, operation );
}
VkResult vkDeferredOperationJoinKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDeferredOperationJoinKHR( device, operation );
}
//=== VK_KHR_pipeline_executable_properties ===
VkResult vkGetPipelineExecutablePropertiesKHR( VkDevice device,
const VkPipelineInfoKHR * pPipelineInfo,
uint32_t * pExecutableCount,
VkPipelineExecutablePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties );
}
VkResult vkGetPipelineExecutableStatisticsKHR( VkDevice device,
const VkPipelineExecutableInfoKHR * pExecutableInfo,
uint32_t * pStatisticCount,
VkPipelineExecutableStatisticKHR * pStatistics ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics );
}
VkResult
vkGetPipelineExecutableInternalRepresentationsKHR( VkDevice device,
const VkPipelineExecutableInfoKHR * pExecutableInfo,
uint32_t * pInternalRepresentationCount,
VkPipelineExecutableInternalRepresentationKHR * pInternalRepresentations ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPipelineExecutableInternalRepresentationsKHR( device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations );
}
//=== VK_EXT_host_image_copy ===
VkResult vkCopyMemoryToImageEXT( VkDevice device, const VkCopyMemoryToImageInfoEXT * pCopyMemoryToImageInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCopyMemoryToImageEXT( device, pCopyMemoryToImageInfo );
}
VkResult vkCopyImageToMemoryEXT( VkDevice device, const VkCopyImageToMemoryInfoEXT * pCopyImageToMemoryInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCopyImageToMemoryEXT( device, pCopyImageToMemoryInfo );
}
VkResult vkCopyImageToImageEXT( VkDevice device, const VkCopyImageToImageInfoEXT * pCopyImageToImageInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCopyImageToImageEXT( device, pCopyImageToImageInfo );
}
VkResult
vkTransitionImageLayoutEXT( VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfoEXT * pTransitions ) const VULKAN_HPP_NOEXCEPT
{
return ::vkTransitionImageLayoutEXT( device, transitionCount, pTransitions );
}
void vkGetImageSubresourceLayout2EXT( VkDevice device,
VkImage image,
const VkImageSubresource2KHR * pSubresource,
VkSubresourceLayout2KHR * pLayout ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageSubresourceLayout2EXT( device, image, pSubresource, pLayout );
}
//=== VK_KHR_map_memory2 ===
VkResult vkMapMemory2KHR( VkDevice device, const VkMemoryMapInfoKHR * pMemoryMapInfo, void ** ppData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkMapMemory2KHR( device, pMemoryMapInfo, ppData );
}
VkResult vkUnmapMemory2KHR( VkDevice device, const VkMemoryUnmapInfoKHR * pMemoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkUnmapMemory2KHR( device, pMemoryUnmapInfo );
}
//=== VK_EXT_swapchain_maintenance1 ===
VkResult vkReleaseSwapchainImagesEXT( VkDevice device, const VkReleaseSwapchainImagesInfoEXT * pReleaseInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkReleaseSwapchainImagesEXT( device, pReleaseInfo );
}
//=== VK_NV_device_generated_commands ===
void vkGetGeneratedCommandsMemoryRequirementsNV( VkDevice device,
const VkGeneratedCommandsMemoryRequirementsInfoNV * pInfo,
VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetGeneratedCommandsMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
}
void vkCmdPreprocessGeneratedCommandsNV( VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdPreprocessGeneratedCommandsNV( commandBuffer, pGeneratedCommandsInfo );
}
void vkCmdExecuteGeneratedCommandsNV( VkCommandBuffer commandBuffer,
VkBool32 isPreprocessed,
const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdExecuteGeneratedCommandsNV( commandBuffer, isPreprocessed, pGeneratedCommandsInfo );
}
void vkCmdBindPipelineShaderGroupNV( VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipeline pipeline,
uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindPipelineShaderGroupNV( commandBuffer, pipelineBindPoint, pipeline, groupIndex );
}
VkResult vkCreateIndirectCommandsLayoutNV( VkDevice device,
const VkIndirectCommandsLayoutCreateInfoNV * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkIndirectCommandsLayoutNV * pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateIndirectCommandsLayoutNV( device, pCreateInfo, pAllocator, pIndirectCommandsLayout );
}
void vkDestroyIndirectCommandsLayoutNV( VkDevice device,
VkIndirectCommandsLayoutNV indirectCommandsLayout,
const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyIndirectCommandsLayoutNV( device, indirectCommandsLayout, pAllocator );
}
//=== VK_EXT_depth_bias_control ===
void vkCmdSetDepthBias2EXT( VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT * pDepthBiasInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthBias2EXT( commandBuffer, pDepthBiasInfo );
}
//=== VK_EXT_acquire_drm_display ===
VkResult vkAcquireDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
{
return ::vkAcquireDrmDisplayEXT( physicalDevice, drmFd, display );
}
VkResult vkGetDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR * display ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDrmDisplayEXT( physicalDevice, drmFd, connectorId, display );
}
//=== VK_EXT_private_data ===
VkResult vkCreatePrivateDataSlotEXT( VkDevice device,
const VkPrivateDataSlotCreateInfo * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkPrivateDataSlot * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreatePrivateDataSlotEXT( device, pCreateInfo, pAllocator, pPrivateDataSlot );
}
void vkDestroyPrivateDataSlotEXT( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyPrivateDataSlotEXT( device, privateDataSlot, pAllocator );
}
VkResult vkSetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const
VULKAN_HPP_NOEXCEPT
{
return ::vkSetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, data );
}
void vkGetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const
VULKAN_HPP_NOEXCEPT
{
return ::vkGetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, pData );
}
//=== VK_KHR_video_encode_queue ===
VkResult
vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo,
VkVideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( physicalDevice, pQualityLevelInfo, pQualityLevelProperties );
}
VkResult vkGetEncodedVideoSessionParametersKHR( VkDevice device,
const VkVideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo,
VkVideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo,
size_t * pDataSize,
void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetEncodedVideoSessionParametersKHR( device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData );
}
void vkCmdEncodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR * pEncodeInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdEncodeVideoKHR( commandBuffer, pEncodeInfo );
}
# if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_cuda_kernel_launch ===
VkResult vkCreateCudaModuleNV( VkDevice device,
const VkCudaModuleCreateInfoNV * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkCudaModuleNV * pModule ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateCudaModuleNV( device, pCreateInfo, pAllocator, pModule );
}
VkResult vkGetCudaModuleCacheNV( VkDevice device, VkCudaModuleNV module, size_t * pCacheSize, void * pCacheData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetCudaModuleCacheNV( device, module, pCacheSize, pCacheData );
}
VkResult vkCreateCudaFunctionNV( VkDevice device,
const VkCudaFunctionCreateInfoNV * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkCudaFunctionNV * pFunction ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateCudaFunctionNV( device, pCreateInfo, pAllocator, pFunction );
}
void vkDestroyCudaModuleNV( VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyCudaModuleNV( device, module, pAllocator );
}
void vkDestroyCudaFunctionNV( VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyCudaFunctionNV( device, function, pAllocator );
}
void vkCmdCudaLaunchKernelNV( VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCudaLaunchKernelNV( commandBuffer, pLaunchInfo );
}
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
# if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_objects ===
void vkExportMetalObjectsEXT( VkDevice device, VkExportMetalObjectsInfoEXT * pMetalObjectsInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkExportMetalObjectsEXT( device, pMetalObjectsInfo );
}
# endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_synchronization2 ===
void vkCmdSetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetEvent2KHR( commandBuffer, event, pDependencyInfo );
}
void vkCmdResetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdResetEvent2KHR( commandBuffer, event, stageMask );
}
void vkCmdWaitEvents2KHR( VkCommandBuffer commandBuffer,
uint32_t eventCount,
const VkEvent * pEvents,
const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdWaitEvents2KHR( commandBuffer, eventCount, pEvents, pDependencyInfos );
}
void vkCmdPipelineBarrier2KHR( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdPipelineBarrier2KHR( commandBuffer, pDependencyInfo );
}
void vkCmdWriteTimestamp2KHR( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdWriteTimestamp2KHR( commandBuffer, stage, queryPool, query );
}
VkResult vkQueueSubmit2KHR( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
{
return ::vkQueueSubmit2KHR( queue, submitCount, pSubmits, fence );
}
void vkCmdWriteBufferMarker2AMD(
VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdWriteBufferMarker2AMD( commandBuffer, stage, dstBuffer, dstOffset, marker );
}
void vkGetQueueCheckpointData2NV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointData2NV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetQueueCheckpointData2NV( queue, pCheckpointDataCount, pCheckpointData );
}
//=== VK_EXT_descriptor_buffer ===
void vkGetDescriptorSetLayoutSizeEXT( VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize * pLayoutSizeInBytes ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDescriptorSetLayoutSizeEXT( device, layout, pLayoutSizeInBytes );
}
void vkGetDescriptorSetLayoutBindingOffsetEXT( VkDevice device,
VkDescriptorSetLayout layout,
uint32_t binding,
VkDeviceSize * pOffset ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDescriptorSetLayoutBindingOffsetEXT( device, layout, binding, pOffset );
}
void vkGetDescriptorEXT( VkDevice device, const VkDescriptorGetInfoEXT * pDescriptorInfo, size_t dataSize, void * pDescriptor ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDescriptorEXT( device, pDescriptorInfo, dataSize, pDescriptor );
}
void vkCmdBindDescriptorBuffersEXT( VkCommandBuffer commandBuffer,
uint32_t bufferCount,
const VkDescriptorBufferBindingInfoEXT * pBindingInfos ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindDescriptorBuffersEXT( commandBuffer, bufferCount, pBindingInfos );
}
void vkCmdSetDescriptorBufferOffsetsEXT( VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
uint32_t firstSet,
uint32_t setCount,
const uint32_t * pBufferIndices,
const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDescriptorBufferOffsetsEXT( commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets );
}
void vkCmdBindDescriptorBufferEmbeddedSamplersEXT( VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
uint32_t set ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindDescriptorBufferEmbeddedSamplersEXT( commandBuffer, pipelineBindPoint, layout, set );
}
VkResult
vkGetBufferOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetBufferOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
}
VkResult
vkGetImageOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkImageCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
}
VkResult vkGetImageViewOpaqueCaptureDescriptorDataEXT( VkDevice device,
const VkImageViewCaptureDescriptorDataInfoEXT * pInfo,
void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageViewOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
}
VkResult
vkGetSamplerOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetSamplerOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
}
VkResult vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( VkDevice device,
const VkAccelerationStructureCaptureDescriptorDataInfoEXT * pInfo,
void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
}
//=== VK_NV_fragment_shading_rate_enums ===
void vkCmdSetFragmentShadingRateEnumNV( VkCommandBuffer commandBuffer,
VkFragmentShadingRateNV shadingRate,
const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetFragmentShadingRateEnumNV( commandBuffer, shadingRate, combinerOps );
}
//=== VK_EXT_mesh_shader ===
void vkCmdDrawMeshTasksEXT( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawMeshTasksEXT( commandBuffer, groupCountX, groupCountY, groupCountZ );
}
void vkCmdDrawMeshTasksIndirectEXT( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawMeshTasksIndirectEXT( commandBuffer, buffer, offset, drawCount, stride );
}
void vkCmdDrawMeshTasksIndirectCountEXT( VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawMeshTasksIndirectCountEXT( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
}
//=== VK_KHR_copy_commands2 ===
void vkCmdCopyBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyBuffer2KHR( commandBuffer, pCopyBufferInfo );
}
void vkCmdCopyImage2KHR( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyImage2KHR( commandBuffer, pCopyImageInfo );
}
void vkCmdCopyBufferToImage2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyBufferToImage2KHR( commandBuffer, pCopyBufferToImageInfo );
}
void vkCmdCopyImageToBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyImageToBuffer2KHR( commandBuffer, pCopyImageToBufferInfo );
}
void vkCmdBlitImage2KHR( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBlitImage2KHR( commandBuffer, pBlitImageInfo );
}
void vkCmdResolveImage2KHR( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdResolveImage2KHR( commandBuffer, pResolveImageInfo );
}
//=== VK_EXT_device_fault ===
VkResult vkGetDeviceFaultInfoEXT( VkDevice device, VkDeviceFaultCountsEXT * pFaultCounts, VkDeviceFaultInfoEXT * pFaultInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceFaultInfoEXT( device, pFaultCounts, pFaultInfo );
}
# if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_acquire_winrt_display ===
VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
{
return ::vkAcquireWinrtDisplayNV( physicalDevice, display );
}
VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay );
}
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
# if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
//=== VK_EXT_directfb_surface ===
VkResult vkCreateDirectFBSurfaceEXT( VkInstance instance,
const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateDirectFBSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
}
VkBool32
vkGetPhysicalDeviceDirectFBPresentationSupportEXT( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB * dfb ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT( physicalDevice, queueFamilyIndex, dfb );
}
# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
//=== VK_EXT_vertex_input_dynamic_state ===
void vkCmdSetVertexInputEXT( VkCommandBuffer commandBuffer,
uint32_t vertexBindingDescriptionCount,
const VkVertexInputBindingDescription2EXT * pVertexBindingDescriptions,
uint32_t vertexAttributeDescriptionCount,
const VkVertexInputAttributeDescription2EXT * pVertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetVertexInputEXT(
commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions );
}
# if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_external_memory ===
VkResult vkGetMemoryZirconHandleFUCHSIA( VkDevice device,
const VkMemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetMemoryZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
}
VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA( VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
zx_handle_t zirconHandle,
VkMemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetMemoryZirconHandlePropertiesFUCHSIA( device, handleType, zirconHandle, pMemoryZirconHandleProperties );
}
# endif /*VK_USE_PLATFORM_FUCHSIA*/
# if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_external_semaphore ===
VkResult vkImportSemaphoreZirconHandleFUCHSIA( VkDevice device,
const VkImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkImportSemaphoreZirconHandleFUCHSIA( device, pImportSemaphoreZirconHandleInfo );
}
VkResult vkGetSemaphoreZirconHandleFUCHSIA( VkDevice device,
const VkSemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetSemaphoreZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
}
# endif /*VK_USE_PLATFORM_FUCHSIA*/
# if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_buffer_collection ===
VkResult vkCreateBufferCollectionFUCHSIA( VkDevice device,
const VkBufferCollectionCreateInfoFUCHSIA * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkBufferCollectionFUCHSIA * pCollection ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateBufferCollectionFUCHSIA( device, pCreateInfo, pAllocator, pCollection );
}
VkResult vkSetBufferCollectionImageConstraintsFUCHSIA( VkDevice device,
VkBufferCollectionFUCHSIA collection,
const VkImageConstraintsInfoFUCHSIA * pImageConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkSetBufferCollectionImageConstraintsFUCHSIA( device, collection, pImageConstraintsInfo );
}
VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA( VkDevice device,
VkBufferCollectionFUCHSIA collection,
const VkBufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkSetBufferCollectionBufferConstraintsFUCHSIA( device, collection, pBufferConstraintsInfo );
}
void vkDestroyBufferCollectionFUCHSIA( VkDevice device,
VkBufferCollectionFUCHSIA collection,
const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyBufferCollectionFUCHSIA( device, collection, pAllocator );
}
VkResult vkGetBufferCollectionPropertiesFUCHSIA( VkDevice device,
VkBufferCollectionFUCHSIA collection,
VkBufferCollectionPropertiesFUCHSIA * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetBufferCollectionPropertiesFUCHSIA( device, collection, pProperties );
}
# endif /*VK_USE_PLATFORM_FUCHSIA*/
//=== VK_HUAWEI_subpass_shading ===
VkResult
vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( VkDevice device, VkRenderPass renderpass, VkExtent2D * pMaxWorkgroupSize ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( device, renderpass, pMaxWorkgroupSize );
}
void vkCmdSubpassShadingHUAWEI( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSubpassShadingHUAWEI( commandBuffer );
}
//=== VK_HUAWEI_invocation_mask ===
void vkCmdBindInvocationMaskHUAWEI( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindInvocationMaskHUAWEI( commandBuffer, imageView, imageLayout );
}
//=== VK_NV_external_memory_rdma ===
VkResult vkGetMemoryRemoteAddressNV( VkDevice device,
const VkMemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
VkRemoteAddressNV * pAddress ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetMemoryRemoteAddressNV( device, pMemoryGetRemoteAddressInfo, pAddress );
}
//=== VK_EXT_pipeline_properties ===
VkResult
vkGetPipelinePropertiesEXT( VkDevice device, const VkPipelineInfoEXT * pPipelineInfo, VkBaseOutStructure * pPipelineProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPipelinePropertiesEXT( device, pPipelineInfo, pPipelineProperties );
}
//=== VK_EXT_extended_dynamic_state2 ===
void vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer, uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetPatchControlPointsEXT( commandBuffer, patchControlPoints );
}
void vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetRasterizerDiscardEnableEXT( commandBuffer, rasterizerDiscardEnable );
}
void vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthBiasEnableEXT( commandBuffer, depthBiasEnable );
}
void vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetLogicOpEXT( commandBuffer, logicOp );
}
void vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetPrimitiveRestartEnableEXT( commandBuffer, primitiveRestartEnable );
}
# if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_screen_surface ===
VkResult vkCreateScreenSurfaceQNX( VkInstance instance,
const VkScreenSurfaceCreateInfoQNX * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateScreenSurfaceQNX( instance, pCreateInfo, pAllocator, pSurface );
}
VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX( VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
struct _screen_window * window ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceScreenPresentationSupportQNX( physicalDevice, queueFamilyIndex, window );
}
# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_EXT_color_write_enable ===
void vkCmdSetColorWriteEnableEXT( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 * pColorWriteEnables ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetColorWriteEnableEXT( commandBuffer, attachmentCount, pColorWriteEnables );
}
//=== VK_KHR_ray_tracing_maintenance1 ===
void vkCmdTraceRaysIndirect2KHR( VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdTraceRaysIndirect2KHR( commandBuffer, indirectDeviceAddress );
}
//=== VK_EXT_multi_draw ===
void vkCmdDrawMultiEXT( VkCommandBuffer commandBuffer,
uint32_t drawCount,
const VkMultiDrawInfoEXT * pVertexInfo,
uint32_t instanceCount,
uint32_t firstInstance,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawMultiEXT( commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride );
}
void vkCmdDrawMultiIndexedEXT( VkCommandBuffer commandBuffer,
uint32_t drawCount,
const VkMultiDrawIndexedInfoEXT * pIndexInfo,
uint32_t instanceCount,
uint32_t firstInstance,
uint32_t stride,
const int32_t * pVertexOffset ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawMultiIndexedEXT( commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset );
}
//=== VK_EXT_opacity_micromap ===
VkResult vkCreateMicromapEXT( VkDevice device,
const VkMicromapCreateInfoEXT * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkMicromapEXT * pMicromap ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateMicromapEXT( device, pCreateInfo, pAllocator, pMicromap );
}
void vkDestroyMicromapEXT( VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyMicromapEXT( device, micromap, pAllocator );
}
void vkCmdBuildMicromapsEXT( VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBuildMicromapsEXT( commandBuffer, infoCount, pInfos );
}
VkResult vkBuildMicromapsEXT( VkDevice device,
VkDeferredOperationKHR deferredOperation,
uint32_t infoCount,
const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT
{
return ::vkBuildMicromapsEXT( device, deferredOperation, infoCount, pInfos );
}
VkResult vkCopyMicromapEXT( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCopyMicromapEXT( device, deferredOperation, pInfo );
}
VkResult vkCopyMicromapToMemoryEXT( VkDevice device,
VkDeferredOperationKHR deferredOperation,
const VkCopyMicromapToMemoryInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCopyMicromapToMemoryEXT( device, deferredOperation, pInfo );
}
VkResult vkCopyMemoryToMicromapEXT( VkDevice device,
VkDeferredOperationKHR deferredOperation,
const VkCopyMemoryToMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCopyMemoryToMicromapEXT( device, deferredOperation, pInfo );
}
VkResult vkWriteMicromapsPropertiesEXT( VkDevice device,
uint32_t micromapCount,
const VkMicromapEXT * pMicromaps,
VkQueryType queryType,
size_t dataSize,
void * pData,
size_t stride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkWriteMicromapsPropertiesEXT( device, micromapCount, pMicromaps, queryType, dataSize, pData, stride );
}
void vkCmdCopyMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyMicromapEXT( commandBuffer, pInfo );
}
void vkCmdCopyMicromapToMemoryEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyMicromapToMemoryEXT( commandBuffer, pInfo );
}
void vkCmdCopyMemoryToMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyMemoryToMicromapEXT( commandBuffer, pInfo );
}
void vkCmdWriteMicromapsPropertiesEXT( VkCommandBuffer commandBuffer,
uint32_t micromapCount,
const VkMicromapEXT * pMicromaps,
VkQueryType queryType,
VkQueryPool queryPool,
uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdWriteMicromapsPropertiesEXT( commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery );
}
void vkGetDeviceMicromapCompatibilityEXT( VkDevice device,
const VkMicromapVersionInfoEXT * pVersionInfo,
VkAccelerationStructureCompatibilityKHR * pCompatibility ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceMicromapCompatibilityEXT( device, pVersionInfo, pCompatibility );
}
void vkGetMicromapBuildSizesEXT( VkDevice device,
VkAccelerationStructureBuildTypeKHR buildType,
const VkMicromapBuildInfoEXT * pBuildInfo,
VkMicromapBuildSizesInfoEXT * pSizeInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetMicromapBuildSizesEXT( device, buildType, pBuildInfo, pSizeInfo );
}
//=== VK_HUAWEI_cluster_culling_shader ===
void vkCmdDrawClusterHUAWEI( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawClusterHUAWEI( commandBuffer, groupCountX, groupCountY, groupCountZ );
}
void vkCmdDrawClusterIndirectHUAWEI( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawClusterIndirectHUAWEI( commandBuffer, buffer, offset );
}
//=== VK_EXT_pageable_device_local_memory ===
void vkSetDeviceMemoryPriorityEXT( VkDevice device, VkDeviceMemory memory, float priority ) const VULKAN_HPP_NOEXCEPT
{
return ::vkSetDeviceMemoryPriorityEXT( device, memory, priority );
}
//=== VK_KHR_maintenance4 ===
void vkGetDeviceBufferMemoryRequirementsKHR( VkDevice device,
const VkDeviceBufferMemoryRequirements * pInfo,
VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceBufferMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
}
void vkGetDeviceImageMemoryRequirementsKHR( VkDevice device,
const VkDeviceImageMemoryRequirements * pInfo,
VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceImageMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
}
void vkGetDeviceImageSparseMemoryRequirementsKHR( VkDevice device,
const VkDeviceImageMemoryRequirements * pInfo,
uint32_t * pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceImageSparseMemoryRequirementsKHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
}
//=== VK_VALVE_descriptor_set_host_mapping ===
void vkGetDescriptorSetLayoutHostMappingInfoVALVE( VkDevice device,
const VkDescriptorSetBindingReferenceVALVE * pBindingReference,
VkDescriptorSetLayoutHostMappingInfoVALVE * pHostMapping ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDescriptorSetLayoutHostMappingInfoVALVE( device, pBindingReference, pHostMapping );
}
void vkGetDescriptorSetHostMappingVALVE( VkDevice device, VkDescriptorSet descriptorSet, void ** ppData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDescriptorSetHostMappingVALVE( device, descriptorSet, ppData );
}
//=== VK_NV_copy_memory_indirect ===
void vkCmdCopyMemoryIndirectNV( VkCommandBuffer commandBuffer,
VkDeviceAddress copyBufferAddress,
uint32_t copyCount,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyMemoryIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride );
}
void vkCmdCopyMemoryToImageIndirectNV( VkCommandBuffer commandBuffer,
VkDeviceAddress copyBufferAddress,
uint32_t copyCount,
uint32_t stride,
VkImage dstImage,
VkImageLayout dstImageLayout,
const VkImageSubresourceLayers * pImageSubresources ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyMemoryToImageIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources );
}
//=== VK_NV_memory_decompression ===
void vkCmdDecompressMemoryNV( VkCommandBuffer commandBuffer,
uint32_t decompressRegionCount,
const VkDecompressMemoryRegionNV * pDecompressMemoryRegions ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDecompressMemoryNV( commandBuffer, decompressRegionCount, pDecompressMemoryRegions );
}
void vkCmdDecompressMemoryIndirectCountNV( VkCommandBuffer commandBuffer,
VkDeviceAddress indirectCommandsAddress,
VkDeviceAddress indirectCommandsCountAddress,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDecompressMemoryIndirectCountNV( commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride );
}
//=== VK_NV_device_generated_commands_compute ===
void vkGetPipelineIndirectMemoryRequirementsNV( VkDevice device,
const VkComputePipelineCreateInfo * pCreateInfo,
VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPipelineIndirectMemoryRequirementsNV( device, pCreateInfo, pMemoryRequirements );
}
void
vkCmdUpdatePipelineIndirectBufferNV( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdUpdatePipelineIndirectBufferNV( commandBuffer, pipelineBindPoint, pipeline );
}
VkDeviceAddress vkGetPipelineIndirectDeviceAddressNV( VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV * pInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPipelineIndirectDeviceAddressNV( device, pInfo );
}
//=== VK_EXT_extended_dynamic_state3 ===
void vkCmdSetDepthClampEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthClampEnableEXT( commandBuffer, depthClampEnable );
}
void vkCmdSetPolygonModeEXT( VkCommandBuffer commandBuffer, VkPolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetPolygonModeEXT( commandBuffer, polygonMode );
}
void vkCmdSetRasterizationSamplesEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetRasterizationSamplesEXT( commandBuffer, rasterizationSamples );
}
void vkCmdSetSampleMaskEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask * pSampleMask ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetSampleMaskEXT( commandBuffer, samples, pSampleMask );
}
void vkCmdSetAlphaToCoverageEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetAlphaToCoverageEnableEXT( commandBuffer, alphaToCoverageEnable );
}
void vkCmdSetAlphaToOneEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetAlphaToOneEnableEXT( commandBuffer, alphaToOneEnable );
}
void vkCmdSetLogicOpEnableEXT( VkCommandBuffer commandBuffer, VkBool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetLogicOpEnableEXT( commandBuffer, logicOpEnable );
}
void vkCmdSetColorBlendEnableEXT( VkCommandBuffer commandBuffer,
uint32_t firstAttachment,
uint32_t attachmentCount,
const VkBool32 * pColorBlendEnables ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetColorBlendEnableEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables );
}
void vkCmdSetColorBlendEquationEXT( VkCommandBuffer commandBuffer,
uint32_t firstAttachment,
uint32_t attachmentCount,
const VkColorBlendEquationEXT * pColorBlendEquations ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetColorBlendEquationEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations );
}
void vkCmdSetColorWriteMaskEXT( VkCommandBuffer commandBuffer,
uint32_t firstAttachment,
uint32_t attachmentCount,
const VkColorComponentFlags * pColorWriteMasks ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetColorWriteMaskEXT( commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks );
}
void vkCmdSetTessellationDomainOriginEXT( VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetTessellationDomainOriginEXT( commandBuffer, domainOrigin );
}
void vkCmdSetRasterizationStreamEXT( VkCommandBuffer commandBuffer, uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetRasterizationStreamEXT( commandBuffer, rasterizationStream );
}
void vkCmdSetConservativeRasterizationModeEXT( VkCommandBuffer commandBuffer,
VkConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetConservativeRasterizationModeEXT( commandBuffer, conservativeRasterizationMode );
}
void vkCmdSetExtraPrimitiveOverestimationSizeEXT( VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetExtraPrimitiveOverestimationSizeEXT( commandBuffer, extraPrimitiveOverestimationSize );
}
void vkCmdSetDepthClipEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthClipEnableEXT( commandBuffer, depthClipEnable );
}
void vkCmdSetSampleLocationsEnableEXT( VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetSampleLocationsEnableEXT( commandBuffer, sampleLocationsEnable );
}
void vkCmdSetColorBlendAdvancedEXT( VkCommandBuffer commandBuffer,
uint32_t firstAttachment,
uint32_t attachmentCount,
const VkColorBlendAdvancedEXT * pColorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetColorBlendAdvancedEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced );
}
void vkCmdSetProvokingVertexModeEXT( VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetProvokingVertexModeEXT( commandBuffer, provokingVertexMode );
}
void vkCmdSetLineRasterizationModeEXT( VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetLineRasterizationModeEXT( commandBuffer, lineRasterizationMode );
}
void vkCmdSetLineStippleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetLineStippleEnableEXT( commandBuffer, stippledLineEnable );
}
void vkCmdSetDepthClipNegativeOneToOneEXT( VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDepthClipNegativeOneToOneEXT( commandBuffer, negativeOneToOne );
}
void vkCmdSetViewportWScalingEnableNV( VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetViewportWScalingEnableNV( commandBuffer, viewportWScalingEnable );
}
void vkCmdSetViewportSwizzleNV( VkCommandBuffer commandBuffer,
uint32_t firstViewport,
uint32_t viewportCount,
const VkViewportSwizzleNV * pViewportSwizzles ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetViewportSwizzleNV( commandBuffer, firstViewport, viewportCount, pViewportSwizzles );
}
void vkCmdSetCoverageToColorEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetCoverageToColorEnableNV( commandBuffer, coverageToColorEnable );
}
void vkCmdSetCoverageToColorLocationNV( VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetCoverageToColorLocationNV( commandBuffer, coverageToColorLocation );
}
void vkCmdSetCoverageModulationModeNV( VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetCoverageModulationModeNV( commandBuffer, coverageModulationMode );
}
void vkCmdSetCoverageModulationTableEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetCoverageModulationTableEnableNV( commandBuffer, coverageModulationTableEnable );
}
void vkCmdSetCoverageModulationTableNV( VkCommandBuffer commandBuffer,
uint32_t coverageModulationTableCount,
const float * pCoverageModulationTable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetCoverageModulationTableNV( commandBuffer, coverageModulationTableCount, pCoverageModulationTable );
}
void vkCmdSetShadingRateImageEnableNV( VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetShadingRateImageEnableNV( commandBuffer, shadingRateImageEnable );
}
void vkCmdSetRepresentativeFragmentTestEnableNV( VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetRepresentativeFragmentTestEnableNV( commandBuffer, representativeFragmentTestEnable );
}
void vkCmdSetCoverageReductionModeNV( VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetCoverageReductionModeNV( commandBuffer, coverageReductionMode );
}
//=== VK_EXT_shader_module_identifier ===
void vkGetShaderModuleIdentifierEXT( VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetShaderModuleIdentifierEXT( device, shaderModule, pIdentifier );
}
void vkGetShaderModuleCreateInfoIdentifierEXT( VkDevice device,
const VkShaderModuleCreateInfo * pCreateInfo,
VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetShaderModuleCreateInfoIdentifierEXT( device, pCreateInfo, pIdentifier );
}
//=== VK_NV_optical_flow ===
VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV( VkPhysicalDevice physicalDevice,
const VkOpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo,
uint32_t * pFormatCount,
VkOpticalFlowImageFormatPropertiesNV * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceOpticalFlowImageFormatsNV( physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties );
}
VkResult vkCreateOpticalFlowSessionNV( VkDevice device,
const VkOpticalFlowSessionCreateInfoNV * pCreateInfo,
const VkAllocationCallbacks * pAllocator,
VkOpticalFlowSessionNV * pSession ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateOpticalFlowSessionNV( device, pCreateInfo, pAllocator, pSession );
}
void vkDestroyOpticalFlowSessionNV( VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyOpticalFlowSessionNV( device, session, pAllocator );
}
VkResult vkBindOpticalFlowSessionImageNV( VkDevice device,
VkOpticalFlowSessionNV session,
VkOpticalFlowSessionBindingPointNV bindingPoint,
VkImageView view,
VkImageLayout layout ) const VULKAN_HPP_NOEXCEPT
{
return ::vkBindOpticalFlowSessionImageNV( device, session, bindingPoint, view, layout );
}
void vkCmdOpticalFlowExecuteNV( VkCommandBuffer commandBuffer,
VkOpticalFlowSessionNV session,
const VkOpticalFlowExecuteInfoNV * pExecuteInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdOpticalFlowExecuteNV( commandBuffer, session, pExecuteInfo );
}
//=== VK_KHR_maintenance5 ===
void vkCmdBindIndexBuffer2KHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType ) const
VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindIndexBuffer2KHR( commandBuffer, buffer, offset, size, indexType );
}
void vkGetRenderingAreaGranularityKHR( VkDevice device,
const VkRenderingAreaInfoKHR * pRenderingAreaInfo,
VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetRenderingAreaGranularityKHR( device, pRenderingAreaInfo, pGranularity );
}
void vkGetDeviceImageSubresourceLayoutKHR( VkDevice device,
const VkDeviceImageSubresourceInfoKHR * pInfo,
VkSubresourceLayout2KHR * pLayout ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceImageSubresourceLayoutKHR( device, pInfo, pLayout );
}
void vkGetImageSubresourceLayout2KHR( VkDevice device,
VkImage image,
const VkImageSubresource2KHR * pSubresource,
VkSubresourceLayout2KHR * pLayout ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageSubresourceLayout2KHR( device, image, pSubresource, pLayout );
}
//=== VK_AMD_anti_lag ===
void vkAntiLagUpdateAMD( VkDevice device, const VkAntiLagDataAMD * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkAntiLagUpdateAMD( device, pData );
}
//=== VK_EXT_shader_object ===
VkResult vkCreateShadersEXT( VkDevice device,
uint32_t createInfoCount,
const VkShaderCreateInfoEXT * pCreateInfos,
const VkAllocationCallbacks * pAllocator,
VkShaderEXT * pShaders ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateShadersEXT( device, createInfoCount, pCreateInfos, pAllocator, pShaders );
}
void vkDestroyShaderEXT( VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
{
return ::vkDestroyShaderEXT( device, shader, pAllocator );
}
VkResult vkGetShaderBinaryDataEXT( VkDevice device, VkShaderEXT shader, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetShaderBinaryDataEXT( device, shader, pDataSize, pData );
}
void vkCmdBindShadersEXT( VkCommandBuffer commandBuffer,
uint32_t stageCount,
const VkShaderStageFlagBits * pStages,
const VkShaderEXT * pShaders ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindShadersEXT( commandBuffer, stageCount, pStages, pShaders );
}
//=== VK_QCOM_tile_properties ===
VkResult vkGetFramebufferTilePropertiesQCOM( VkDevice device,
VkFramebuffer framebuffer,
uint32_t * pPropertiesCount,
VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetFramebufferTilePropertiesQCOM( device, framebuffer, pPropertiesCount, pProperties );
}
VkResult vkGetDynamicRenderingTilePropertiesQCOM( VkDevice device,
const VkRenderingInfo * pRenderingInfo,
VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDynamicRenderingTilePropertiesQCOM( device, pRenderingInfo, pProperties );
}
//=== VK_NV_low_latency2 ===
VkResult vkSetLatencySleepModeNV( VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV * pSleepModeInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkSetLatencySleepModeNV( device, swapchain, pSleepModeInfo );
}
VkResult vkLatencySleepNV( VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV * pSleepInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkLatencySleepNV( device, swapchain, pSleepInfo );
}
void vkSetLatencyMarkerNV( VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV * pLatencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkSetLatencyMarkerNV( device, swapchain, pLatencyMarkerInfo );
}
void vkGetLatencyTimingsNV( VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV * pLatencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetLatencyTimingsNV( device, swapchain, pLatencyMarkerInfo );
}
void vkQueueNotifyOutOfBandNV( VkQueue queue, const VkOutOfBandQueueTypeInfoNV * pQueueTypeInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkQueueNotifyOutOfBandNV( queue, pQueueTypeInfo );
}
//=== VK_KHR_cooperative_matrix ===
VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( VkPhysicalDevice physicalDevice,
uint32_t * pPropertyCount,
VkCooperativeMatrixPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
}
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
void vkCmdSetAttachmentFeedbackLoopEnableEXT( VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetAttachmentFeedbackLoopEnableEXT( commandBuffer, aspectMask );
}
# if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_external_memory_screen_buffer ===
VkResult vkGetScreenBufferPropertiesQNX( VkDevice device,
const struct _screen_buffer * buffer,
VkScreenBufferPropertiesQNX * pProperties ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetScreenBufferPropertiesQNX( device, buffer, pProperties );
}
# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_KHR_line_rasterization ===
void vkCmdSetLineStippleKHR( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetLineStippleKHR( commandBuffer, lineStippleFactor, lineStipplePattern );
}
//=== VK_KHR_calibrated_timestamps ===
VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( VkPhysicalDevice physicalDevice,
uint32_t * pTimeDomainCount,
VkTimeDomainKHR * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( physicalDevice, pTimeDomainCount, pTimeDomains );
}
VkResult vkGetCalibratedTimestampsKHR( VkDevice device,
uint32_t timestampCount,
const VkCalibratedTimestampInfoKHR * pTimestampInfos,
uint64_t * pTimestamps,
uint64_t * pMaxDeviation ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetCalibratedTimestampsKHR( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
}
//=== VK_KHR_maintenance6 ===
void vkCmdBindDescriptorSets2KHR( VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR * pBindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindDescriptorSets2KHR( commandBuffer, pBindDescriptorSetsInfo );
}
void vkCmdPushConstants2KHR( VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR * pPushConstantsInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdPushConstants2KHR( commandBuffer, pPushConstantsInfo );
}
void vkCmdPushDescriptorSet2KHR( VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR * pPushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdPushDescriptorSet2KHR( commandBuffer, pPushDescriptorSetInfo );
}
void vkCmdPushDescriptorSetWithTemplate2KHR( VkCommandBuffer commandBuffer,
const VkPushDescriptorSetWithTemplateInfoKHR * pPushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdPushDescriptorSetWithTemplate2KHR( commandBuffer, pPushDescriptorSetWithTemplateInfo );
}
void vkCmdSetDescriptorBufferOffsets2EXT( VkCommandBuffer commandBuffer,
const VkSetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdSetDescriptorBufferOffsets2EXT( commandBuffer, pSetDescriptorBufferOffsetsInfo );
}
void vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(
VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo );
}
};
inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic()
{
static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls;
return dls;
}
#endif
#if ( 14 <= VULKAN_HPP_CPP_VERSION )
using std::exchange;
#else
template <class T, class U = T>
VULKAN_HPP_CONSTEXPR_14 VULKAN_HPP_INLINE T exchange( T & obj, U && newValue )
{
T oldValue = std::move( obj );
obj = std::forward<U>( newValue );
return oldValue;
}
#endif
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
struct AllocationCallbacks;
template <typename OwnerType, typename Dispatch>
class ObjectDestroy
{
public:
ObjectDestroy() = default;
ObjectDestroy( OwnerType owner,
Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
{
return m_allocationCallbacks;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_owner && m_dispatch );
m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
}
private:
OwnerType m_owner = {};
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
class NoParent;
template <typename Dispatch>
class ObjectDestroy<NoParent, Dispatch>
{
public:
ObjectDestroy() = default;
ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{
}
Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
{
return m_allocationCallbacks;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_dispatch );
t.destroy( m_allocationCallbacks, *m_dispatch );
}
private:
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
template <typename OwnerType, typename Dispatch>
class ObjectFree
{
public:
ObjectFree() = default;
ObjectFree( OwnerType owner,
Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
{
return m_allocationCallbacks;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_owner && m_dispatch );
( m_owner.free )( t, m_allocationCallbacks, *m_dispatch );
}
private:
OwnerType m_owner = {};
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
template <typename OwnerType, typename Dispatch>
class ObjectRelease
{
public:
ObjectRelease() = default;
ObjectRelease( OwnerType owner, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_owner && m_dispatch );
m_owner.release( t, *m_dispatch );
}
private:
OwnerType m_owner = {};
Dispatch const * m_dispatch = nullptr;
};
template <typename OwnerType, typename PoolType, typename Dispatch>
class PoolFree
{
public:
PoolFree() = default;
PoolFree( OwnerType owner, PoolType pool, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_pool( pool )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
PoolType getPool() const VULKAN_HPP_NOEXCEPT
{
return m_pool;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
( m_owner.free )( m_pool, t, *m_dispatch );
}
private:
OwnerType m_owner = OwnerType();
PoolType m_pool = PoolType();
Dispatch const * m_dispatch = nullptr;
};
#endif // !VULKAN_HPP_NO_SMART_HANDLE
//==================
//=== BASE TYPEs ===
//==================
using Bool32 = uint32_t;
using DeviceAddress = uint64_t;
using DeviceSize = uint64_t;
using RemoteAddressNV = void *;
using SampleMask = uint32_t;
template <typename Type, Type value = Type{}>
struct CppType
{
};
} // namespace VULKAN_HPP_NAMESPACE
#include <vulkan/vulkan_enums.hpp>
#if !defined( VULKAN_HPP_NO_TO_STRING )
# include <vulkan/vulkan_to_string.hpp>
#endif
#ifndef VULKAN_HPP_NO_EXCEPTIONS
namespace std
{
template <>
struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
{
};
} // namespace std
#endif
namespace VULKAN_HPP_NAMESPACE
{
#ifndef VULKAN_HPP_NO_EXCEPTIONS
class ErrorCategoryImpl : public std::error_category
{
public:
virtual const char * name() const VULKAN_HPP_NOEXCEPT override
{
return VULKAN_HPP_NAMESPACE_STRING "::Result";
}
virtual std::string message( int ev ) const override
{
# if defined( VULKAN_HPP_NO_TO_STRING )
return std::to_string( ev );
# else
return VULKAN_HPP_NAMESPACE::to_string( static_cast<VULKAN_HPP_NAMESPACE::Result>( ev ) );
# endif
}
};
class Error
{
public:
Error() VULKAN_HPP_NOEXCEPT = default;
Error( const Error & ) VULKAN_HPP_NOEXCEPT = default;
virtual ~Error() VULKAN_HPP_NOEXCEPT = default;
virtual const char * what() const VULKAN_HPP_NOEXCEPT = 0;
};
class LogicError
: public Error
, public std::logic_error
{
public:
explicit LogicError( const std::string & what ) : Error(), std::logic_error( what ) {}
explicit LogicError( char const * what ) : Error(), std::logic_error( what ) {}
virtual const char * what() const VULKAN_HPP_NOEXCEPT
{
return std::logic_error::what();
}
};
class SystemError
: public Error
, public std::system_error
{
public:
SystemError( std::error_code ec ) : Error(), std::system_error( ec ) {}
SystemError( std::error_code ec, std::string const & what ) : Error(), std::system_error( ec, what ) {}
SystemError( std::error_code ec, char const * what ) : Error(), std::system_error( ec, what ) {}
SystemError( int ev, std::error_category const & ecat ) : Error(), std::system_error( ev, ecat ) {}
SystemError( int ev, std::error_category const & ecat, std::string const & what ) : Error(), std::system_error( ev, ecat, what ) {}
SystemError( int ev, std::error_category const & ecat, char const * what ) : Error(), std::system_error( ev, ecat, what ) {}
virtual const char * what() const VULKAN_HPP_NOEXCEPT
{
return std::system_error::what();
}
};
VULKAN_HPP_INLINE const std::error_category & errorCategory() VULKAN_HPP_NOEXCEPT
{
static ErrorCategoryImpl instance;
return instance;
}
VULKAN_HPP_INLINE std::error_code make_error_code( Result e ) VULKAN_HPP_NOEXCEPT
{
return std::error_code( static_cast<int>( e ), errorCategory() );
}
VULKAN_HPP_INLINE std::error_condition make_error_condition( Result e ) VULKAN_HPP_NOEXCEPT
{
return std::error_condition( static_cast<int>( e ), errorCategory() );
}
class OutOfHostMemoryError : public SystemError
{
public:
OutOfHostMemoryError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
OutOfHostMemoryError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
};
class OutOfDeviceMemoryError : public SystemError
{
public:
OutOfDeviceMemoryError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
OutOfDeviceMemoryError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
};
class InitializationFailedError : public SystemError
{
public:
InitializationFailedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
InitializationFailedError( char const * message ) : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
};
class DeviceLostError : public SystemError
{
public:
DeviceLostError( std::string const & message ) : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
DeviceLostError( char const * message ) : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
};
class MemoryMapFailedError : public SystemError
{
public:
MemoryMapFailedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
MemoryMapFailedError( char const * message ) : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
};
class LayerNotPresentError : public SystemError
{
public:
LayerNotPresentError( std::string const & message ) : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
LayerNotPresentError( char const * message ) : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
};
class ExtensionNotPresentError : public SystemError
{
public:
ExtensionNotPresentError( std::string const & message ) : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
ExtensionNotPresentError( char const * message ) : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
};
class FeatureNotPresentError : public SystemError
{
public:
FeatureNotPresentError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
FeatureNotPresentError( char const * message ) : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
};
class IncompatibleDriverError : public SystemError
{
public:
IncompatibleDriverError( std::string const & message ) : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
IncompatibleDriverError( char const * message ) : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
};
class TooManyObjectsError : public SystemError
{
public:
TooManyObjectsError( std::string const & message ) : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
TooManyObjectsError( char const * message ) : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
};
class FormatNotSupportedError : public SystemError
{
public:
FormatNotSupportedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
FormatNotSupportedError( char const * message ) : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
};
class FragmentedPoolError : public SystemError
{
public:
FragmentedPoolError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
FragmentedPoolError( char const * message ) : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
};
class UnknownError : public SystemError
{
public:
UnknownError( std::string const & message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {}
UnknownError( char const * message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {}
};
class OutOfPoolMemoryError : public SystemError
{
public:
OutOfPoolMemoryError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
OutOfPoolMemoryError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
};
class InvalidExternalHandleError : public SystemError
{
public:
InvalidExternalHandleError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
InvalidExternalHandleError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
};
class FragmentationError : public SystemError
{
public:
FragmentationError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFragmentation ), message ) {}
FragmentationError( char const * message ) : SystemError( make_error_code( Result::eErrorFragmentation ), message ) {}
};
class InvalidOpaqueCaptureAddressError : public SystemError
{
public:
InvalidOpaqueCaptureAddressError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {}
InvalidOpaqueCaptureAddressError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {}
};
class SurfaceLostKHRError : public SystemError
{
public:
SurfaceLostKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
SurfaceLostKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
};
class NativeWindowInUseKHRError : public SystemError
{
public:
NativeWindowInUseKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
NativeWindowInUseKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
};
class OutOfDateKHRError : public SystemError
{
public:
OutOfDateKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
OutOfDateKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
};
class IncompatibleDisplayKHRError : public SystemError
{
public:
IncompatibleDisplayKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
IncompatibleDisplayKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
};
class ValidationFailedEXTError : public SystemError
{
public:
ValidationFailedEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
ValidationFailedEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
};
class InvalidShaderNVError : public SystemError
{
public:
InvalidShaderNVError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
InvalidShaderNVError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
};
class ImageUsageNotSupportedKHRError : public SystemError
{
public:
ImageUsageNotSupportedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {}
ImageUsageNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {}
};
class VideoPictureLayoutNotSupportedKHRError : public SystemError
{
public:
VideoPictureLayoutNotSupportedKHRError( std::string const & message )
: SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message )
{
}
VideoPictureLayoutNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message )
{
}
};
class VideoProfileOperationNotSupportedKHRError : public SystemError
{
public:
VideoProfileOperationNotSupportedKHRError( std::string const & message )
: SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message )
{
}
VideoProfileOperationNotSupportedKHRError( char const * message )
: SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message )
{
}
};
class VideoProfileFormatNotSupportedKHRError : public SystemError
{
public:
VideoProfileFormatNotSupportedKHRError( std::string const & message )
: SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message )
{
}
VideoProfileFormatNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message )
{
}
};
class VideoProfileCodecNotSupportedKHRError : public SystemError
{
public:
VideoProfileCodecNotSupportedKHRError( std::string const & message )
: SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message )
{
}
VideoProfileCodecNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message ) {}
};
class VideoStdVersionNotSupportedKHRError : public SystemError
{
public:
VideoStdVersionNotSupportedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message )
{
}
VideoStdVersionNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message ) {}
};
class InvalidDrmFormatModifierPlaneLayoutEXTError : public SystemError
{
public:
InvalidDrmFormatModifierPlaneLayoutEXTError( std::string const & message )
: SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message )
{
}
InvalidDrmFormatModifierPlaneLayoutEXTError( char const * message )
: SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message )
{
}
};
class NotPermittedKHRError : public SystemError
{
public:
NotPermittedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNotPermittedKHR ), message ) {}
NotPermittedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorNotPermittedKHR ), message ) {}
};
# if defined( VK_USE_PLATFORM_WIN32_KHR )
class FullScreenExclusiveModeLostEXTError : public SystemError
{
public:
FullScreenExclusiveModeLostEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message )
{
}
FullScreenExclusiveModeLostEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {}
};
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
class InvalidVideoStdParametersKHRError : public SystemError
{
public:
InvalidVideoStdParametersKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidVideoStdParametersKHR ), message ) {}
InvalidVideoStdParametersKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidVideoStdParametersKHR ), message ) {}
};
class CompressionExhaustedEXTError : public SystemError
{
public:
CompressionExhaustedEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {}
CompressionExhaustedEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {}
};
namespace detail
{
[[noreturn]] VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
{
switch ( result )
{
case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError( message );
case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError( message );
case Result::eErrorInitializationFailed: throw InitializationFailedError( message );
case Result::eErrorDeviceLost: throw DeviceLostError( message );
case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError( message );
case Result::eErrorLayerNotPresent: throw LayerNotPresentError( message );
case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError( message );
case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError( message );
case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError( message );
case Result::eErrorTooManyObjects: throw TooManyObjectsError( message );
case Result::eErrorFormatNotSupported: throw FormatNotSupportedError( message );
case Result::eErrorFragmentedPool: throw FragmentedPoolError( message );
case Result::eErrorUnknown: throw UnknownError( message );
case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError( message );
case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError( message );
case Result::eErrorFragmentation: throw FragmentationError( message );
case Result::eErrorInvalidOpaqueCaptureAddress: throw InvalidOpaqueCaptureAddressError( message );
case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError( message );
case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError( message );
case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError( message );
case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError( message );
case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError( message );
case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError( message );
case Result::eErrorImageUsageNotSupportedKHR: throw ImageUsageNotSupportedKHRError( message );
case Result::eErrorVideoPictureLayoutNotSupportedKHR: throw VideoPictureLayoutNotSupportedKHRError( message );
case Result::eErrorVideoProfileOperationNotSupportedKHR: throw VideoProfileOperationNotSupportedKHRError( message );
case Result::eErrorVideoProfileFormatNotSupportedKHR: throw VideoProfileFormatNotSupportedKHRError( message );
case Result::eErrorVideoProfileCodecNotSupportedKHR: throw VideoProfileCodecNotSupportedKHRError( message );
case Result::eErrorVideoStdVersionNotSupportedKHR: throw VideoStdVersionNotSupportedKHRError( message );
case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError( message );
case Result::eErrorNotPermittedKHR: throw NotPermittedKHRError( message );
# if defined( VK_USE_PLATFORM_WIN32_KHR )
case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError( message );
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
case Result::eErrorInvalidVideoStdParametersKHR: throw InvalidVideoStdParametersKHRError( message );
case Result::eErrorCompressionExhaustedEXT: throw CompressionExhaustedEXTError( message );
default: throw SystemError( make_error_code( result ), message );
}
}
} // namespace detail
#endif
template <typename T>
struct ResultValue
{
#ifdef VULKAN_HPP_HAS_NOEXCEPT
ResultValue( Result r, T & v ) VULKAN_HPP_NOEXCEPT( VULKAN_HPP_NOEXCEPT( T( v ) ) )
#else
ResultValue( Result r, T & v )
#endif
: result( r ), value( v )
{
}
#ifdef VULKAN_HPP_HAS_NOEXCEPT
ResultValue( Result r, T && v ) VULKAN_HPP_NOEXCEPT( VULKAN_HPP_NOEXCEPT( T( std::move( v ) ) ) )
#else
ResultValue( Result r, T && v )
#endif
: result( r ), value( std::move( v ) )
{
}
Result result;
T value;
operator std::tuple<Result &, T &>() VULKAN_HPP_NOEXCEPT
{
return std::tuple<Result &, T &>( result, value );
}
};
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
template <typename Type, typename Dispatch>
struct ResultValue<UniqueHandle<Type, Dispatch>>
{
# ifdef VULKAN_HPP_HAS_NOEXCEPT
ResultValue( Result r, UniqueHandle<Type, Dispatch> && v ) VULKAN_HPP_NOEXCEPT
# else
ResultValue( Result r, UniqueHandle<Type, Dispatch> && v )
# endif
: result( r )
, value( std::move( v ) )
{
}
VULKAN_HPP_DEPRECATED(
"asTuple() on an l-value is deprecated, as it implicitly moves the UniqueHandle out of the ResultValue. Use asTuple() on an r-value instead, requiring to explicitly move the UniqueHandle." )
std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple() &
{
return std::make_tuple( result, std::move( value ) );
}
std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple() &&
{
return std::make_tuple( result, std::move( value ) );
}
Result result;
UniqueHandle<Type, Dispatch> value;
};
template <typename Type, typename Dispatch>
struct ResultValue<std::vector<UniqueHandle<Type, Dispatch>>>
{
# ifdef VULKAN_HPP_HAS_NOEXCEPT
ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v ) VULKAN_HPP_NOEXCEPT
# else
ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v )
# endif
: result( r )
, value( std::move( v ) )
{
}
VULKAN_HPP_DEPRECATED(
"asTuple() on an l-value is deprecated, as it implicitly moves the UniqueHandle out of the ResultValue. Use asTuple() on an r-value instead, requiring to explicitly move the UniqueHandle." )
std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple() &
{
return std::make_tuple( result, std::move( value ) );
}
std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple() &&
{
return std::make_tuple( result, std::move( value ) );
}
Result result;
std::vector<UniqueHandle<Type, Dispatch>> value;
};
#endif
template <typename T>
struct ResultValueType
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
using type = ResultValue<T>;
#else
using type = T;
#endif
};
template <>
struct ResultValueType<void>
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
using type = Result;
#else
using type = void;
#endif
};
namespace detail
{
template <typename T>
void ignore( T const & ) VULKAN_HPP_NOEXCEPT
{
}
VULKAN_HPP_INLINE typename VULKAN_HPP_NAMESPACE::ResultValueType<void>::type createResultValueType( VULKAN_HPP_NAMESPACE::Result result )
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
return result;
#else
VULKAN_HPP_NAMESPACE::detail::ignore( result );
#endif
}
template <typename T>
VULKAN_HPP_INLINE typename VULKAN_HPP_NAMESPACE::ResultValueType<T>::type createResultValueType( VULKAN_HPP_NAMESPACE::Result result, T & data )
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
return ResultValue<T>( result, data );
#else
VULKAN_HPP_NAMESPACE::detail::ignore( result );
return data;
#endif
}
template <typename T>
VULKAN_HPP_INLINE typename VULKAN_HPP_NAMESPACE::ResultValueType<T>::type createResultValueType( VULKAN_HPP_NAMESPACE::Result result, T && data )
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
return ResultValue<T>( result, std::move( data ) );
#else
VULKAN_HPP_NAMESPACE::detail::ignore( result );
return std::move( data );
#endif
}
} // namespace detail
namespace detail
{
VULKAN_HPP_INLINE void resultCheck( Result result, char const * message )
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_NAMESPACE::detail::ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
VULKAN_HPP_NAMESPACE::detail::ignore( message );
VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess );
#else
if ( result != Result::eSuccess )
{
VULKAN_HPP_NAMESPACE::detail::throwResultException( result, message );
}
#endif
}
VULKAN_HPP_INLINE void resultCheck( Result result, char const * message, std::initializer_list<Result> successCodes )
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_NAMESPACE::detail::ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
VULKAN_HPP_NAMESPACE::detail::ignore( message );
VULKAN_HPP_NAMESPACE::detail::ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
#else
if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
{
VULKAN_HPP_NAMESPACE::detail::throwResultException( result, message );
}
#endif
}
} // namespace detail
//===========================
//=== CONSTEXPR CONSTANTs ===
//===========================
//=== VK_VERSION_1_0 ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t AttachmentUnused = VK_ATTACHMENT_UNUSED;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t False = VK_FALSE;
VULKAN_HPP_CONSTEXPR_INLINE float LodClampNone = VK_LOD_CLAMP_NONE;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyIgnored = VK_QUEUE_FAMILY_IGNORED;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t RemainingArrayLayers = VK_REMAINING_ARRAY_LAYERS;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t RemainingMipLevels = VK_REMAINING_MIP_LEVELS;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t SubpassExternal = VK_SUBPASS_EXTERNAL;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t True = VK_TRUE;
VULKAN_HPP_CONSTEXPR_INLINE uint64_t WholeSize = VK_WHOLE_SIZE;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxMemoryTypes = VK_MAX_MEMORY_TYPES;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxPhysicalDeviceNameSize = VK_MAX_PHYSICAL_DEVICE_NAME_SIZE;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t UuidSize = VK_UUID_SIZE;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxExtensionNameSize = VK_MAX_EXTENSION_NAME_SIZE;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDescriptionSize = VK_MAX_DESCRIPTION_SIZE;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxMemoryHeaps = VK_MAX_MEMORY_HEAPS;
//=== VK_VERSION_1_1 ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDeviceGroupSize = VK_MAX_DEVICE_GROUP_SIZE;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t LuidSize = VK_LUID_SIZE;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyExternal = VK_QUEUE_FAMILY_EXTERNAL;
//=== VK_VERSION_1_2 ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverNameSize = VK_MAX_DRIVER_NAME_SIZE;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverInfoSize = VK_MAX_DRIVER_INFO_SIZE;
//=== VK_KHR_device_group_creation ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDeviceGroupSizeKHR = VK_MAX_DEVICE_GROUP_SIZE_KHR;
//=== VK_KHR_external_memory_capabilities ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t LuidSizeKHR = VK_LUID_SIZE_KHR;
//=== VK_KHR_external_memory ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyExternalKHR = VK_QUEUE_FAMILY_EXTERNAL_KHR;
//=== VK_EXT_queue_family_foreign ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyForeignEXT = VK_QUEUE_FAMILY_FOREIGN_EXT;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_shader_enqueue ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderIndexUnusedAMDX = VK_SHADER_INDEX_UNUSED_AMDX;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_KHR_ray_tracing_pipeline ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderUnusedKHR = VK_SHADER_UNUSED_KHR;
//=== VK_NV_ray_tracing ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderUnusedNV = VK_SHADER_UNUSED_NV;
//=== VK_KHR_global_priority ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySizeKHR = VK_MAX_GLOBAL_PRIORITY_SIZE_KHR;
//=== VK_KHR_driver_properties ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverNameSizeKHR = VK_MAX_DRIVER_NAME_SIZE_KHR;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverInfoSizeKHR = VK_MAX_DRIVER_INFO_SIZE_KHR;
//=== VK_EXT_global_priority_query ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySizeEXT = VK_MAX_GLOBAL_PRIORITY_SIZE_EXT;
//=== VK_EXT_image_sliced_view_of_3d ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Remaining3DSlicesEXT = VK_REMAINING_3D_SLICES_EXT;
//=== VK_EXT_shader_module_identifier ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxShaderModuleIdentifierSizeEXT = VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT;
//=== VK_KHR_video_decode_av1 ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxVideoAv1ReferencesPerFrameKHR = VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR;
//========================
//=== CONSTEXPR VALUEs ===
//========================
VULKAN_HPP_CONSTEXPR_INLINE uint32_t HeaderVersion = VK_HEADER_VERSION;
//=========================
//=== CONSTEXPR CALLEEs ===
//=========================
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_CONSTEXPR uint32_t apiVersionMajor( T const version )
{
return ( ( (uint32_t)( version ) >> 22U ) & 0x7FU );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_CONSTEXPR uint32_t apiVersionMinor( T const version )
{
return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_CONSTEXPR uint32_t apiVersionPatch( T const version )
{
return ( (uint32_t)(version)&0xFFFU );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_CONSTEXPR uint32_t apiVersionVariant( T const version )
{
return ( (uint32_t)( version ) >> 29U );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_CONSTEXPR uint32_t makeApiVersion( T const variant, T const major, T const minor, T const patch )
{
return ( ( ( (uint32_t)( variant ) ) << 29U ) | ( ( (uint32_t)( major ) ) << 22U ) | ( ( (uint32_t)( minor ) ) << 12U ) | ( (uint32_t)( patch ) ) );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_MAKE_API_VERSION should be used instead." )
VULKAN_HPP_CONSTEXPR uint32_t makeVersion( T const major, T const minor, T const patch )
{
return ( ( ( (uint32_t)( major ) ) << 22U ) | ( ( (uint32_t)( minor ) ) << 12U ) | ( (uint32_t)( patch ) ) );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_API_VERSION_MAJOR should be used instead." )
VULKAN_HPP_CONSTEXPR uint32_t versionMajor( T const version )
{
return ( (uint32_t)( version ) >> 22U );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_API_VERSION_MINOR should be used instead." )
VULKAN_HPP_CONSTEXPR uint32_t versionMinor( T const version )
{
return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_API_VERSION_PATCH should be used instead." )
VULKAN_HPP_CONSTEXPR uint32_t versionPatch( T const version )
{
return ( (uint32_t)(version)&0xFFFU );
}
//=========================
//=== CONSTEXPR CALLERs ===
//=========================
VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion = makeApiVersion( 0, 1, 0, 0 );
VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion10 = makeApiVersion( 0, 1, 0, 0 );
VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion11 = makeApiVersion( 0, 1, 1, 0 );
VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion12 = makeApiVersion( 0, 1, 2, 0 );
VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion13 = makeApiVersion( 0, 1, 3, 0 );
VULKAN_HPP_CONSTEXPR_INLINE auto HeaderVersionComplete = makeApiVersion( 0, 1, 3, VK_HEADER_VERSION );
//=================================
//=== CONSTEXPR EXTENSION NAMEs ===
//=================================
//=== VK_KHR_surface ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceExtensionName = VK_KHR_SURFACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceSpecVersion = VK_KHR_SURFACE_SPEC_VERSION;
//=== VK_KHR_swapchain ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainExtensionName = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainSpecVersion = VK_KHR_SWAPCHAIN_SPEC_VERSION;
//=== VK_KHR_display ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplayExtensionName = VK_KHR_DISPLAY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplaySpecVersion = VK_KHR_DISPLAY_SPEC_VERSION;
//=== VK_KHR_display_swapchain ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplaySwapchainExtensionName = VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplaySwapchainSpecVersion = VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_XLIB_KHR )
//=== VK_KHR_xlib_surface ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRXlibSurfaceExtensionName = VK_KHR_XLIB_SURFACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRXlibSurfaceSpecVersion = VK_KHR_XLIB_SURFACE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
#if defined( VK_USE_PLATFORM_XCB_KHR )
//=== VK_KHR_xcb_surface ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRXcbSurfaceExtensionName = VK_KHR_XCB_SURFACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRXcbSurfaceSpecVersion = VK_KHR_XCB_SURFACE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_XCB_KHR*/
#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
//=== VK_KHR_wayland_surface ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRWaylandSurfaceExtensionName = VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRWaylandSurfaceSpecVersion = VK_KHR_WAYLAND_SURFACE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_KHR_android_surface ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRAndroidSurfaceExtensionName = VK_KHR_ANDROID_SURFACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRAndroidSurfaceSpecVersion = VK_KHR_ANDROID_SURFACE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_win32_surface ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32SurfaceExtensionName = VK_KHR_WIN32_SURFACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32SurfaceSpecVersion = VK_KHR_WIN32_SURFACE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_debug_report ===
VULKAN_HPP_DEPRECATED( "The VK_EXT_debug_report extension has been deprecated by VK_EXT_debug_utils." )
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugReportExtensionName = VK_EXT_DEBUG_REPORT_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_EXT_debug_report extension has been deprecated by VK_EXT_debug_utils." )
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugReportSpecVersion = VK_EXT_DEBUG_REPORT_SPEC_VERSION;
//=== VK_NV_glsl_shader ===
VULKAN_HPP_DEPRECATED( "The VK_NV_glsl_shader extension has been deprecated." )
VULKAN_HPP_CONSTEXPR_INLINE auto NVGlslShaderExtensionName = VK_NV_GLSL_SHADER_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_NV_glsl_shader extension has been deprecated." )
VULKAN_HPP_CONSTEXPR_INLINE auto NVGlslShaderSpecVersion = VK_NV_GLSL_SHADER_SPEC_VERSION;
//=== VK_EXT_depth_range_unrestricted ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthRangeUnrestrictedExtensionName = VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthRangeUnrestrictedSpecVersion = VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION;
//=== VK_KHR_sampler_mirror_clamp_to_edge ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerMirrorClampToEdgeExtensionName = VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerMirrorClampToEdgeSpecVersion = VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION;
//=== VK_IMG_filter_cubic ===
VULKAN_HPP_CONSTEXPR_INLINE auto IMGFilterCubicExtensionName = VK_IMG_FILTER_CUBIC_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto IMGFilterCubicSpecVersion = VK_IMG_FILTER_CUBIC_SPEC_VERSION;
//=== VK_AMD_rasterization_order ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDRasterizationOrderExtensionName = VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDRasterizationOrderSpecVersion = VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION;
//=== VK_AMD_shader_trinary_minmax ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderTrinaryMinmaxExtensionName = VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderTrinaryMinmaxSpecVersion = VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION;
//=== VK_AMD_shader_explicit_vertex_parameter ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderExplicitVertexParameterExtensionName = VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderExplicitVertexParameterSpecVersion = VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION;
//=== VK_EXT_debug_marker ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugMarkerExtensionName = VK_EXT_DEBUG_MARKER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugMarkerSpecVersion = VK_EXT_DEBUG_MARKER_SPEC_VERSION;
//=== VK_KHR_video_queue ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoQueueExtensionName = VK_KHR_VIDEO_QUEUE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoQueueSpecVersion = VK_KHR_VIDEO_QUEUE_SPEC_VERSION;
//=== VK_KHR_video_decode_queue ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeQueueExtensionName = VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeQueueSpecVersion = VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION;
//=== VK_AMD_gcn_shader ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDGcnShaderExtensionName = VK_AMD_GCN_SHADER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDGcnShaderSpecVersion = VK_AMD_GCN_SHADER_SPEC_VERSION;
//=== VK_NV_dedicated_allocation ===
VULKAN_HPP_DEPRECATED( "The VK_NV_dedicated_allocation extension has been deprecated by VK_KHR_dedicated_allocation." )
VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationExtensionName = VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_NV_dedicated_allocation extension has been deprecated by VK_KHR_dedicated_allocation." )
VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationSpecVersion = VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION;
//=== VK_EXT_transform_feedback ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTTransformFeedbackExtensionName = VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTTransformFeedbackSpecVersion = VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION;
//=== VK_NVX_binary_import ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVXBinaryImportExtensionName = VK_NVX_BINARY_IMPORT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVXBinaryImportSpecVersion = VK_NVX_BINARY_IMPORT_SPEC_VERSION;
//=== VK_NVX_image_view_handle ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVXImageViewHandleExtensionName = VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVXImageViewHandleSpecVersion = VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION;
//=== VK_AMD_draw_indirect_count ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDDrawIndirectCountExtensionName = VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDDrawIndirectCountSpecVersion = VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION;
//=== VK_AMD_negative_viewport_height ===
VULKAN_HPP_DEPRECATED( "The VK_AMD_negative_viewport_height extension has been obsoleted by VK_KHR_maintenance1." )
VULKAN_HPP_CONSTEXPR_INLINE auto AMDNegativeViewportHeightExtensionName = VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_AMD_negative_viewport_height extension has been obsoleted by VK_KHR_maintenance1." )
VULKAN_HPP_CONSTEXPR_INLINE auto AMDNegativeViewportHeightSpecVersion = VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION;
//=== VK_AMD_gpu_shader_half_float ===
VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_half_float extension has been deprecated by VK_KHR_shader_float16_int8." )
VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderHalfFloatExtensionName = VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_half_float extension has been deprecated by VK_KHR_shader_float16_int8." )
VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderHalfFloatSpecVersion = VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION;
//=== VK_AMD_shader_ballot ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderBallotExtensionName = VK_AMD_SHADER_BALLOT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderBallotSpecVersion = VK_AMD_SHADER_BALLOT_SPEC_VERSION;
//=== VK_KHR_video_encode_h264 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH264ExtensionName = VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH264SpecVersion = VK_KHR_VIDEO_ENCODE_H264_SPEC_VERSION;
//=== VK_KHR_video_encode_h265 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH265ExtensionName = VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH265SpecVersion = VK_KHR_VIDEO_ENCODE_H265_SPEC_VERSION;
//=== VK_KHR_video_decode_h264 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH264ExtensionName = VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH264SpecVersion = VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION;
//=== VK_AMD_texture_gather_bias_lod ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDTextureGatherBiasLodExtensionName = VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDTextureGatherBiasLodSpecVersion = VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION;
//=== VK_AMD_shader_info ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderInfoExtensionName = VK_AMD_SHADER_INFO_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderInfoSpecVersion = VK_AMD_SHADER_INFO_SPEC_VERSION;
//=== VK_KHR_dynamic_rendering ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingExtensionName = VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingSpecVersion = VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION;
//=== VK_AMD_shader_image_load_store_lod ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderImageLoadStoreLodExtensionName = VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderImageLoadStoreLodSpecVersion = VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_GGP )
//=== VK_GGP_stream_descriptor_surface ===
VULKAN_HPP_CONSTEXPR_INLINE auto GGPStreamDescriptorSurfaceExtensionName = VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto GGPStreamDescriptorSurfaceSpecVersion = VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_GGP*/
//=== VK_NV_corner_sampled_image ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVCornerSampledImageExtensionName = VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVCornerSampledImageSpecVersion = VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION;
//=== VK_KHR_multiview ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMultiviewExtensionName = VK_KHR_MULTIVIEW_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMultiviewSpecVersion = VK_KHR_MULTIVIEW_SPEC_VERSION;
//=== VK_IMG_format_pvrtc ===
VULKAN_HPP_DEPRECATED( "The VK_IMG_format_pvrtc extension has been deprecated." )
VULKAN_HPP_CONSTEXPR_INLINE auto IMGFormatPvrtcExtensionName = VK_IMG_FORMAT_PVRTC_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_IMG_format_pvrtc extension has been deprecated." )
VULKAN_HPP_CONSTEXPR_INLINE auto IMGFormatPvrtcSpecVersion = VK_IMG_FORMAT_PVRTC_SPEC_VERSION;
//=== VK_NV_external_memory_capabilities ===
VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_capabilities extension has been deprecated by VK_KHR_external_memory_capabilities." )
VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryCapabilitiesExtensionName = VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_capabilities extension has been deprecated by VK_KHR_external_memory_capabilities." )
VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryCapabilitiesSpecVersion = VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION;
//=== VK_NV_external_memory ===
VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory extension has been deprecated by VK_KHR_external_memory." )
VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryExtensionName = VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory extension has been deprecated by VK_KHR_external_memory." )
VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemorySpecVersion = VK_NV_EXTERNAL_MEMORY_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_external_memory_win32 ===
VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_win32 extension has been deprecated by VK_KHR_external_memory_win32." )
VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryWin32ExtensionName = VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_win32 extension has been deprecated by VK_KHR_external_memory_win32." )
VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryWin32SpecVersion = VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_win32_keyed_mutex ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVWin32KeyedMutexExtensionName = VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVWin32KeyedMutexSpecVersion = VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_get_physical_device_properties2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetPhysicalDeviceProperties2ExtensionName = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetPhysicalDeviceProperties2SpecVersion = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION;
//=== VK_KHR_device_group ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupExtensionName = VK_KHR_DEVICE_GROUP_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupSpecVersion = VK_KHR_DEVICE_GROUP_SPEC_VERSION;
//=== VK_EXT_validation_flags ===
VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_flags extension has been deprecated by VK_EXT_layer_settings." )
VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFlagsExtensionName = VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_flags extension has been deprecated by VK_EXT_layer_settings." )
VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFlagsSpecVersion = VK_EXT_VALIDATION_FLAGS_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_VI_NN )
//=== VK_NN_vi_surface ===
VULKAN_HPP_CONSTEXPR_INLINE auto NNViSurfaceExtensionName = VK_NN_VI_SURFACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NNViSurfaceSpecVersion = VK_NN_VI_SURFACE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_VI_NN*/
//=== VK_KHR_shader_draw_parameters ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderDrawParametersExtensionName = VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderDrawParametersSpecVersion = VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION;
//=== VK_EXT_shader_subgroup_ballot ===
VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_ballot extension has been deprecated by VK_VERSION_1_2." )
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupBallotExtensionName = VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_ballot extension has been deprecated by VK_VERSION_1_2." )
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupBallotSpecVersion = VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION;
//=== VK_EXT_shader_subgroup_vote ===
VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_vote extension has been deprecated by VK_VERSION_1_1." )
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupVoteExtensionName = VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_vote extension has been deprecated by VK_VERSION_1_1." )
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupVoteSpecVersion = VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION;
//=== VK_EXT_texture_compression_astc_hdr ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstcHdrExtensionName = VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstcHdrSpecVersion = VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION;
//=== VK_EXT_astc_decode_mode ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTAstcDecodeModeExtensionName = VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTAstcDecodeModeSpecVersion = VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION;
//=== VK_EXT_pipeline_robustness ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineRobustnessExtensionName = VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineRobustnessSpecVersion = VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION;
//=== VK_KHR_maintenance1 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance1ExtensionName = VK_KHR_MAINTENANCE_1_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance1SpecVersion = VK_KHR_MAINTENANCE_1_SPEC_VERSION;
//=== VK_KHR_device_group_creation ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupCreationExtensionName = VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupCreationSpecVersion = VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION;
//=== VK_KHR_external_memory_capabilities ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryCapabilitiesExtensionName = VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryCapabilitiesSpecVersion = VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION;
//=== VK_KHR_external_memory ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryExtensionName = VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemorySpecVersion = VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_memory_win32 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryWin32ExtensionName = VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryWin32SpecVersion = VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_memory_fd ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryFdExtensionName = VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryFdSpecVersion = VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_win32_keyed_mutex ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32KeyedMutexExtensionName = VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32KeyedMutexSpecVersion = VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_semaphore_capabilities ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreCapabilitiesExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreCapabilitiesSpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION;
//=== VK_KHR_external_semaphore ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreSpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_semaphore_win32 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreWin32ExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreWin32SpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_semaphore_fd ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreFdExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreFdSpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION;
//=== VK_KHR_push_descriptor ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPushDescriptorExtensionName = VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPushDescriptorSpecVersion = VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION;
//=== VK_EXT_conditional_rendering ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTConditionalRenderingExtensionName = VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTConditionalRenderingSpecVersion = VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION;
//=== VK_KHR_shader_float16_int8 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloat16Int8ExtensionName = VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloat16Int8SpecVersion = VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION;
//=== VK_KHR_16bit_storage ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHR16BitStorageExtensionName = VK_KHR_16BIT_STORAGE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHR16BitStorageSpecVersion = VK_KHR_16BIT_STORAGE_SPEC_VERSION;
//=== VK_KHR_incremental_present ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRIncrementalPresentExtensionName = VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRIncrementalPresentSpecVersion = VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION;
//=== VK_KHR_descriptor_update_template ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDescriptorUpdateTemplateExtensionName = VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDescriptorUpdateTemplateSpecVersion = VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION;
//=== VK_NV_clip_space_w_scaling ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVClipSpaceWScalingExtensionName = VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVClipSpaceWScalingSpecVersion = VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION;
//=== VK_EXT_direct_mode_display ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectModeDisplayExtensionName = VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectModeDisplaySpecVersion = VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
//=== VK_EXT_acquire_xlib_display ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireXlibDisplayExtensionName = VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireXlibDisplaySpecVersion = VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
//=== VK_EXT_display_surface_counter ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplaySurfaceCounterExtensionName = VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplaySurfaceCounterSpecVersion = VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION;
//=== VK_EXT_display_control ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplayControlExtensionName = VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplayControlSpecVersion = VK_EXT_DISPLAY_CONTROL_SPEC_VERSION;
//=== VK_GOOGLE_display_timing ===
VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDisplayTimingExtensionName = VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDisplayTimingSpecVersion = VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION;
//=== VK_NV_sample_mask_override_coverage ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVSampleMaskOverrideCoverageExtensionName = VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVSampleMaskOverrideCoverageSpecVersion = VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION;
//=== VK_NV_geometry_shader_passthrough ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVGeometryShaderPassthroughExtensionName = VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVGeometryShaderPassthroughSpecVersion = VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION;
//=== VK_NV_viewport_array2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportArray2ExtensionName = VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportArray2SpecVersion = VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION;
//=== VK_NVX_multiview_per_view_attributes ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVXMultiviewPerViewAttributesExtensionName = VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVXMultiviewPerViewAttributesSpecVersion = VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION;
//=== VK_NV_viewport_swizzle ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportSwizzleExtensionName = VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportSwizzleSpecVersion = VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION;
//=== VK_EXT_discard_rectangles ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDiscardRectanglesExtensionName = VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDiscardRectanglesSpecVersion = VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION;
//=== VK_EXT_conservative_rasterization ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTConservativeRasterizationExtensionName = VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTConservativeRasterizationSpecVersion = VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION;
//=== VK_EXT_depth_clip_enable ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipEnableExtensionName = VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipEnableSpecVersion = VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION;
//=== VK_EXT_swapchain_colorspace ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainColorSpaceExtensionName = VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainColorSpaceSpecVersion = VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION;
//=== VK_EXT_hdr_metadata ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTHdrMetadataExtensionName = VK_EXT_HDR_METADATA_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTHdrMetadataSpecVersion = VK_EXT_HDR_METADATA_SPEC_VERSION;
//=== VK_KHR_imageless_framebuffer ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRImagelessFramebufferExtensionName = VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRImagelessFramebufferSpecVersion = VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION;
//=== VK_KHR_create_renderpass2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRCreateRenderpass2ExtensionName = VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRCreateRenderpass2SpecVersion = VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION;
//=== VK_IMG_relaxed_line_rasterization ===
VULKAN_HPP_CONSTEXPR_INLINE auto IMGRelaxedLineRasterizationExtensionName = VK_IMG_RELAXED_LINE_RASTERIZATION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto IMGRelaxedLineRasterizationSpecVersion = VK_IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION;
//=== VK_KHR_shared_presentable_image ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSharedPresentableImageExtensionName = VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSharedPresentableImageSpecVersion = VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION;
//=== VK_KHR_external_fence_capabilities ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceCapabilitiesExtensionName = VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceCapabilitiesSpecVersion = VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION;
//=== VK_KHR_external_fence ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceExtensionName = VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceSpecVersion = VK_KHR_EXTERNAL_FENCE_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_fence_win32 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceWin32ExtensionName = VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceWin32SpecVersion = VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_fence_fd ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceFdExtensionName = VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceFdSpecVersion = VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION;
//=== VK_KHR_performance_query ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPerformanceQueryExtensionName = VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPerformanceQuerySpecVersion = VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION;
//=== VK_KHR_maintenance2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance2ExtensionName = VK_KHR_MAINTENANCE_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance2SpecVersion = VK_KHR_MAINTENANCE_2_SPEC_VERSION;
//=== VK_KHR_get_surface_capabilities2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetSurfaceCapabilities2ExtensionName = VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetSurfaceCapabilities2SpecVersion = VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION;
//=== VK_KHR_variable_pointers ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVariablePointersExtensionName = VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVariablePointersSpecVersion = VK_KHR_VARIABLE_POINTERS_SPEC_VERSION;
//=== VK_KHR_get_display_properties2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetDisplayProperties2ExtensionName = VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetDisplayProperties2SpecVersion = VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_IOS_MVK )
//=== VK_MVK_ios_surface ===
VULKAN_HPP_DEPRECATED( "The VK_MVK_ios_surface extension has been deprecated by VK_EXT_metal_surface." )
VULKAN_HPP_CONSTEXPR_INLINE auto MVKIosSurfaceExtensionName = VK_MVK_IOS_SURFACE_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_MVK_ios_surface extension has been deprecated by VK_EXT_metal_surface." )
VULKAN_HPP_CONSTEXPR_INLINE auto MVKIosSurfaceSpecVersion = VK_MVK_IOS_SURFACE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_IOS_MVK*/
#if defined( VK_USE_PLATFORM_MACOS_MVK )
//=== VK_MVK_macos_surface ===
VULKAN_HPP_DEPRECATED( "The VK_MVK_macos_surface extension has been deprecated by VK_EXT_metal_surface." )
VULKAN_HPP_CONSTEXPR_INLINE auto MVKMacosSurfaceExtensionName = VK_MVK_MACOS_SURFACE_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_MVK_macos_surface extension has been deprecated by VK_EXT_metal_surface." )
VULKAN_HPP_CONSTEXPR_INLINE auto MVKMacosSurfaceSpecVersion = VK_MVK_MACOS_SURFACE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
//=== VK_EXT_external_memory_dma_buf ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryDmaBufExtensionName = VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryDmaBufSpecVersion = VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION;
//=== VK_EXT_queue_family_foreign ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTQueueFamilyForeignExtensionName = VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTQueueFamilyForeignSpecVersion = VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION;
//=== VK_KHR_dedicated_allocation ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDedicatedAllocationExtensionName = VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDedicatedAllocationSpecVersion = VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION;
//=== VK_EXT_debug_utils ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugUtilsExtensionName = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugUtilsSpecVersion = VK_EXT_DEBUG_UTILS_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_ANDROID_external_memory_android_hardware_buffer ===
VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalMemoryAndroidHardwareBufferExtensionName = your_sha256_hashE;
VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalMemoryAndroidHardwareBufferSpecVersion = VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
//=== VK_EXT_sampler_filter_minmax ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSamplerFilterMinmaxExtensionName = VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSamplerFilterMinmaxSpecVersion = VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION;
//=== VK_KHR_storage_buffer_storage_class ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRStorageBufferStorageClassExtensionName = VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRStorageBufferStorageClassSpecVersion = VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION;
//=== VK_AMD_gpu_shader_int16 ===
VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_int16 extension has been deprecated by VK_KHR_shader_float16_int8." )
VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderInt16ExtensionName = VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_int16 extension has been deprecated by VK_KHR_shader_float16_int8." )
VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderInt16SpecVersion = VK_AMD_GPU_SHADER_INT16_SPEC_VERSION;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_shader_enqueue ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDXShaderEnqueueExtensionName = VK_AMDX_SHADER_ENQUEUE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDXShaderEnqueueSpecVersion = VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_AMD_mixed_attachment_samples ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDMixedAttachmentSamplesExtensionName = VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDMixedAttachmentSamplesSpecVersion = VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION;
//=== VK_AMD_shader_fragment_mask ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderFragmentMaskExtensionName = VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderFragmentMaskSpecVersion = VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION;
//=== VK_EXT_inline_uniform_block ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTInlineUniformBlockExtensionName = VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTInlineUniformBlockSpecVersion = VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION;
//=== VK_EXT_shader_stencil_export ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportExtensionName = VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportSpecVersion = VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION;
//=== VK_EXT_sample_locations ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsExtensionName = VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsSpecVersion = VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION;
//=== VK_KHR_relaxed_block_layout ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRelaxedBlockLayoutExtensionName = VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRelaxedBlockLayoutSpecVersion = VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION;
//=== VK_KHR_get_memory_requirements2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetMemoryRequirements2ExtensionName = VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetMemoryRequirements2SpecVersion = VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION;
//=== VK_KHR_image_format_list ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRImageFormatListExtensionName = VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRImageFormatListSpecVersion = VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION;
//=== VK_EXT_blend_operation_advanced ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTBlendOperationAdvancedExtensionName = VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTBlendOperationAdvancedSpecVersion = VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION;
//=== VK_NV_fragment_coverage_to_color ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentCoverageToColorExtensionName = VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentCoverageToColorSpecVersion = VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION;
//=== VK_KHR_acceleration_structure ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRAccelerationStructureExtensionName = VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRAccelerationStructureSpecVersion = VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION;
//=== VK_KHR_ray_tracing_pipeline ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPipelineExtensionName = VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPipelineSpecVersion = VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION;
//=== VK_KHR_ray_query ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayQueryExtensionName = VK_KHR_RAY_QUERY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayQuerySpecVersion = VK_KHR_RAY_QUERY_SPEC_VERSION;
//=== VK_NV_framebuffer_mixed_samples ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVFramebufferMixedSamplesExtensionName = VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVFramebufferMixedSamplesSpecVersion = VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION;
//=== VK_NV_fill_rectangle ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVFillRectangleExtensionName = VK_NV_FILL_RECTANGLE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVFillRectangleSpecVersion = VK_NV_FILL_RECTANGLE_SPEC_VERSION;
//=== VK_NV_shader_sm_builtins ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSmBuiltinsExtensionName = VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSmBuiltinsSpecVersion = VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION;
//=== VK_EXT_post_depth_coverage ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPostDepthCoverageExtensionName = VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPostDepthCoverageSpecVersion = VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION;
//=== VK_KHR_sampler_ycbcr_conversion ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerYcbcrConversionExtensionName = VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerYcbcrConversionSpecVersion = VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION;
//=== VK_KHR_bind_memory2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRBindMemory2ExtensionName = VK_KHR_BIND_MEMORY_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRBindMemory2SpecVersion = VK_KHR_BIND_MEMORY_2_SPEC_VERSION;
//=== VK_EXT_image_drm_format_modifier ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageDrmFormatModifierExtensionName = VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageDrmFormatModifierSpecVersion = VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION;
//=== VK_EXT_validation_cache ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationCacheExtensionName = VK_EXT_VALIDATION_CACHE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationCacheSpecVersion = VK_EXT_VALIDATION_CACHE_SPEC_VERSION;
//=== VK_EXT_descriptor_indexing ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorIndexingExtensionName = VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorIndexingSpecVersion = VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION;
//=== VK_EXT_shader_viewport_index_layer ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderViewportIndexLayerExtensionName = VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderViewportIndexLayerSpecVersion = VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_portability_subset ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilitySubsetExtensionName = VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilitySubsetSpecVersion = VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_NV_shading_rate_image ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVShadingRateImageExtensionName = VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVShadingRateImageSpecVersion = VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION;
//=== VK_NV_ray_tracing ===
VULKAN_HPP_DEPRECATED( "The VK_NV_ray_tracing extension has been deprecated by VK_KHR_ray_tracing_pipeline." )
VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingExtensionName = VK_NV_RAY_TRACING_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_NV_ray_tracing extension has been deprecated by VK_KHR_ray_tracing_pipeline." )
VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingSpecVersion = VK_NV_RAY_TRACING_SPEC_VERSION;
//=== VK_NV_representative_fragment_test ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVRepresentativeFragmentTestExtensionName = VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVRepresentativeFragmentTestSpecVersion = VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION;
//=== VK_KHR_maintenance3 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance3ExtensionName = VK_KHR_MAINTENANCE_3_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance3SpecVersion = VK_KHR_MAINTENANCE_3_SPEC_VERSION;
//=== VK_KHR_draw_indirect_count ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDrawIndirectCountExtensionName = VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDrawIndirectCountSpecVersion = VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION;
//=== VK_EXT_filter_cubic ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFilterCubicExtensionName = VK_EXT_FILTER_CUBIC_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFilterCubicSpecVersion = VK_EXT_FILTER_CUBIC_SPEC_VERSION;
//=== VK_QCOM_render_pass_shader_resolve ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassShaderResolveExtensionName = VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassShaderResolveSpecVersion = VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION;
//=== VK_EXT_global_priority ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityExtensionName = VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPrioritySpecVersion = VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION;
//=== VK_KHR_shader_subgroup_extended_types ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupExtendedTypesExtensionName = VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupExtendedTypesSpecVersion = VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION;
//=== VK_KHR_8bit_storage ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHR8BitStorageExtensionName = VK_KHR_8BIT_STORAGE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHR8BitStorageSpecVersion = VK_KHR_8BIT_STORAGE_SPEC_VERSION;
//=== VK_EXT_external_memory_host ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryHostExtensionName = VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryHostSpecVersion = VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION;
//=== VK_AMD_buffer_marker ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDBufferMarkerExtensionName = VK_AMD_BUFFER_MARKER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDBufferMarkerSpecVersion = VK_AMD_BUFFER_MARKER_SPEC_VERSION;
//=== VK_KHR_shader_atomic_int64 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderAtomicInt64ExtensionName = VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderAtomicInt64SpecVersion = VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION;
//=== VK_KHR_shader_clock ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderClockExtensionName = VK_KHR_SHADER_CLOCK_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderClockSpecVersion = VK_KHR_SHADER_CLOCK_SPEC_VERSION;
//=== VK_AMD_pipeline_compiler_control ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDPipelineCompilerControlExtensionName = VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDPipelineCompilerControlSpecVersion = VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION;
//=== VK_EXT_calibrated_timestamps ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTCalibratedTimestampsExtensionName = VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTCalibratedTimestampsSpecVersion = VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION;
//=== VK_AMD_shader_core_properties ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCorePropertiesExtensionName = VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCorePropertiesSpecVersion = VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION;
//=== VK_KHR_video_decode_h265 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH265ExtensionName = VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH265SpecVersion = VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION;
//=== VK_KHR_global_priority ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRGlobalPriorityExtensionName = VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRGlobalPrioritySpecVersion = VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION;
//=== VK_AMD_memory_overallocation_behavior ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDMemoryOverallocationBehaviorExtensionName = VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDMemoryOverallocationBehaviorSpecVersion = VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION;
//=== VK_EXT_vertex_attribute_divisor ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeDivisorExtensionName = VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeDivisorSpecVersion = VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_GGP )
//=== VK_GGP_frame_token ===
VULKAN_HPP_CONSTEXPR_INLINE auto GGPFrameTokenExtensionName = VK_GGP_FRAME_TOKEN_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto GGPFrameTokenSpecVersion = VK_GGP_FRAME_TOKEN_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_GGP*/
//=== VK_EXT_pipeline_creation_feedback ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationFeedbackExtensionName = VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationFeedbackSpecVersion = VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION;
//=== VK_KHR_driver_properties ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDriverPropertiesExtensionName = VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDriverPropertiesSpecVersion = VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION;
//=== VK_KHR_shader_float_controls ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControlsExtensionName = VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControlsSpecVersion = VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION;
//=== VK_NV_shader_subgroup_partitioned ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSubgroupPartitionedExtensionName = VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSubgroupPartitionedSpecVersion = VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION;
//=== VK_KHR_depth_stencil_resolve ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthStencilResolveExtensionName = VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthStencilResolveSpecVersion = VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION;
//=== VK_KHR_swapchain_mutable_format ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMutableFormatExtensionName = VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMutableFormatSpecVersion = VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION;
//=== VK_NV_compute_shader_derivatives ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVComputeShaderDerivativesExtensionName = VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVComputeShaderDerivativesSpecVersion = VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION;
//=== VK_NV_mesh_shader ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVMeshShaderExtensionName = VK_NV_MESH_SHADER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVMeshShaderSpecVersion = VK_NV_MESH_SHADER_SPEC_VERSION;
//=== VK_NV_fragment_shader_barycentric ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShaderBarycentricExtensionName = VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShaderBarycentricSpecVersion = VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION;
//=== VK_NV_shader_image_footprint ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderImageFootprintExtensionName = VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderImageFootprintSpecVersion = VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION;
//=== VK_NV_scissor_exclusive ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVScissorExclusiveExtensionName = VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVScissorExclusiveSpecVersion = VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION;
//=== VK_NV_device_diagnostic_checkpoints ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticCheckpointsExtensionName = VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticCheckpointsSpecVersion = VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION;
//=== VK_KHR_timeline_semaphore ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRTimelineSemaphoreExtensionName = VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRTimelineSemaphoreSpecVersion = VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION;
//=== VK_INTEL_shader_integer_functions2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto INTELShaderIntegerFunctions2ExtensionName = VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto INTELShaderIntegerFunctions2SpecVersion = VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION;
//=== VK_INTEL_performance_query ===
VULKAN_HPP_CONSTEXPR_INLINE auto INTELPerformanceQueryExtensionName = VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto INTELPerformanceQuerySpecVersion = VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION;
//=== VK_KHR_vulkan_memory_model ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVulkanMemoryModelExtensionName = VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVulkanMemoryModelSpecVersion = VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION;
//=== VK_EXT_pci_bus_info ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPciBusInfoExtensionName = VK_EXT_PCI_BUS_INFO_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPciBusInfoSpecVersion = VK_EXT_PCI_BUS_INFO_SPEC_VERSION;
//=== VK_AMD_display_native_hdr ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDDisplayNativeHdrExtensionName = VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDDisplayNativeHdrSpecVersion = VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_imagepipe_surface ===
VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAImagepipeSurfaceExtensionName = VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAImagepipeSurfaceSpecVersion = VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_FUCHSIA*/
//=== VK_KHR_shader_terminate_invocation ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderTerminateInvocationExtensionName = VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderTerminateInvocationSpecVersion = VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_surface ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalSurfaceExtensionName = VK_EXT_METAL_SURFACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalSurfaceSpecVersion = VK_EXT_METAL_SURFACE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapSpecVersion = VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION;
//=== VK_EXT_scalar_block_layout ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTScalarBlockLayoutExtensionName = VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTScalarBlockLayoutSpecVersion = VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION;
//=== VK_GOOGLE_hlsl_functionality1 ===
VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEHlslFunctionality1ExtensionName = VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEHlslFunctionality1SpecVersion = VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION;
//=== VK_GOOGLE_decorate_string ===
VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDecorateStringExtensionName = VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDecorateStringSpecVersion = VK_GOOGLE_DECORATE_STRING_SPEC_VERSION;
//=== VK_EXT_subgroup_size_control ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubgroupSizeControlExtensionName = VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubgroupSizeControlSpecVersion = VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION;
//=== VK_KHR_fragment_shading_rate ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShadingRateExtensionName = VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShadingRateSpecVersion = VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION;
//=== VK_AMD_shader_core_properties2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCoreProperties2ExtensionName = VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCoreProperties2SpecVersion = VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION;
//=== VK_AMD_device_coherent_memory ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDDeviceCoherentMemoryExtensionName = VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDDeviceCoherentMemorySpecVersion = VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION;
//=== VK_KHR_dynamic_rendering_local_read ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingLocalReadExtensionName = VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingLocalReadSpecVersion = VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION;
//=== VK_EXT_shader_image_atomic_int64 ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderImageAtomicInt64ExtensionName = VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderImageAtomicInt64SpecVersion = VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION;
//=== VK_KHR_shader_quad_control ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderQuadControlExtensionName = VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderQuadControlSpecVersion = VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION;
//=== VK_KHR_spirv_1_4 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSpirv14ExtensionName = VK_KHR_SPIRV_1_4_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSpirv14SpecVersion = VK_KHR_SPIRV_1_4_SPEC_VERSION;
//=== VK_EXT_memory_budget ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryBudgetExtensionName = VK_EXT_MEMORY_BUDGET_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryBudgetSpecVersion = VK_EXT_MEMORY_BUDGET_SPEC_VERSION;
//=== VK_EXT_memory_priority ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryPriorityExtensionName = VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryPrioritySpecVersion = VK_EXT_MEMORY_PRIORITY_SPEC_VERSION;
//=== VK_KHR_surface_protected_capabilities ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceProtectedCapabilitiesExtensionName = VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceProtectedCapabilitiesSpecVersion = VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION;
//=== VK_NV_dedicated_allocation_image_aliasing ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationImageAliasingExtensionName = VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationImageAliasingSpecVersion = VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION;
//=== VK_KHR_separate_depth_stencil_layouts ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSeparateDepthStencilLayoutsExtensionName = VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSeparateDepthStencilLayoutsSpecVersion = VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION;
//=== VK_EXT_buffer_device_address ===
VULKAN_HPP_DEPRECATED( "The VK_EXT_buffer_device_address extension has been deprecated by VK_KHR_buffer_device_address." )
VULKAN_HPP_CONSTEXPR_INLINE auto EXTBufferDeviceAddressExtensionName = VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_EXT_buffer_device_address extension has been deprecated by VK_KHR_buffer_device_address." )
VULKAN_HPP_CONSTEXPR_INLINE auto EXTBufferDeviceAddressSpecVersion = VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION;
//=== VK_EXT_tooling_info ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTToolingInfoExtensionName = VK_EXT_TOOLING_INFO_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTToolingInfoSpecVersion = VK_EXT_TOOLING_INFO_SPEC_VERSION;
//=== VK_EXT_separate_stencil_usage ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSeparateStencilUsageExtensionName = VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSeparateStencilUsageSpecVersion = VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION;
//=== VK_EXT_validation_features ===
VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_features extension has been deprecated by VK_EXT_layer_settings." )
VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFeaturesExtensionName = VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME;
VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_features extension has been deprecated by VK_EXT_layer_settings." )
VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFeaturesSpecVersion = VK_EXT_VALIDATION_FEATURES_SPEC_VERSION;
//=== VK_KHR_present_wait ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWaitExtensionName = VK_KHR_PRESENT_WAIT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWaitSpecVersion = VK_KHR_PRESENT_WAIT_SPEC_VERSION;
//=== VK_NV_cooperative_matrix ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrixExtensionName = VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrixSpecVersion = VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION;
//=== VK_NV_coverage_reduction_mode ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVCoverageReductionModeExtensionName = VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVCoverageReductionModeSpecVersion = VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION;
//=== VK_EXT_fragment_shader_interlock ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentShaderInterlockExtensionName = VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentShaderInterlockSpecVersion = VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION;
//=== VK_EXT_ycbcr_image_arrays ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcrImageArraysExtensionName = VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcrImageArraysSpecVersion = VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION;
//=== VK_KHR_uniform_buffer_standard_layout ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRUniformBufferStandardLayoutExtensionName = VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRUniformBufferStandardLayoutSpecVersion = VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION;
//=== VK_EXT_provoking_vertex ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTProvokingVertexExtensionName = VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTProvokingVertexSpecVersion = VK_EXT_PROVOKING_VERTEX_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_EXT_full_screen_exclusive ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFullScreenExclusiveExtensionName = VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFullScreenExclusiveSpecVersion = VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_headless_surface ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTHeadlessSurfaceExtensionName = VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTHeadlessSurfaceSpecVersion = VK_EXT_HEADLESS_SURFACE_SPEC_VERSION;
//=== VK_KHR_buffer_device_address ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRBufferDeviceAddressExtensionName = VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRBufferDeviceAddressSpecVersion = VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION;
//=== VK_EXT_line_rasterization ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationExtensionName = VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationSpecVersion = VK_EXT_LINE_RASTERIZATION_SPEC_VERSION;
//=== VK_EXT_shader_atomic_float ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloatExtensionName = VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloatSpecVersion = VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION;
//=== VK_EXT_host_query_reset ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostQueryResetExtensionName = VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostQueryResetSpecVersion = VK_EXT_HOST_QUERY_RESET_SPEC_VERSION;
//=== VK_EXT_index_type_uint8 ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTIndexTypeUint8ExtensionName = VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTIndexTypeUint8SpecVersion = VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION;
//=== VK_EXT_extended_dynamic_state ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicStateExtensionName = VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicStateSpecVersion = VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION;
//=== VK_KHR_deferred_host_operations ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeferredHostOperationsExtensionName = VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeferredHostOperationsSpecVersion = VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION;
//=== VK_KHR_pipeline_executable_properties ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineExecutablePropertiesExtensionName = VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineExecutablePropertiesSpecVersion = VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION;
//=== VK_EXT_host_image_copy ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostImageCopyExtensionName = VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostImageCopySpecVersion = VK_EXT_HOST_IMAGE_COPY_SPEC_VERSION;
//=== VK_KHR_map_memory2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMapMemory2ExtensionName = VK_KHR_MAP_MEMORY_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMapMemory2SpecVersion = VK_KHR_MAP_MEMORY_2_SPEC_VERSION;
//=== VK_EXT_map_memory_placed ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMapMemoryPlacedExtensionName = VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMapMemoryPlacedSpecVersion = VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION;
//=== VK_EXT_shader_atomic_float2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloat2ExtensionName = VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloat2SpecVersion = VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION;
//=== VK_EXT_surface_maintenance1 ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSurfaceMaintenance1ExtensionName = VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSurfaceMaintenance1SpecVersion = VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION;
//=== VK_EXT_swapchain_maintenance1 ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainMaintenance1ExtensionName = VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainMaintenance1SpecVersion = VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION;
//=== VK_EXT_shader_demote_to_helper_invocation ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderDemoteToHelperInvocationExtensionName = VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderDemoteToHelperInvocationSpecVersion = VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION;
//=== VK_NV_device_generated_commands ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsExtensionName = VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsSpecVersion = VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION;
//=== VK_NV_inherited_viewport_scissor ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVInheritedViewportScissorExtensionName = VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVInheritedViewportScissorSpecVersion = VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION;
//=== VK_KHR_shader_integer_dot_product ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderIntegerDotProductExtensionName = VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderIntegerDotProductSpecVersion = VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION;
//=== VK_EXT_texel_buffer_alignment ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTTexelBufferAlignmentExtensionName = VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTTexelBufferAlignmentSpecVersion = VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION;
//=== VK_QCOM_render_pass_transform ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassTransformExtensionName = VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassTransformSpecVersion = VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION;
//=== VK_EXT_depth_bias_control ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthBiasControlExtensionName = VK_EXT_DEPTH_BIAS_CONTROL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthBiasControlSpecVersion = VK_EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION;
//=== VK_EXT_device_memory_report ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceMemoryReportExtensionName = VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceMemoryReportSpecVersion = VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION;
//=== VK_EXT_acquire_drm_display ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireDrmDisplayExtensionName = VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireDrmDisplaySpecVersion = VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION;
//=== VK_EXT_robustness2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTRobustness2ExtensionName = VK_EXT_ROBUSTNESS_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTRobustness2SpecVersion = VK_EXT_ROBUSTNESS_2_SPEC_VERSION;
//=== VK_EXT_custom_border_color ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomBorderColorExtensionName = VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomBorderColorSpecVersion = VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION;
//=== VK_GOOGLE_user_type ===
VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEUserTypeExtensionName = VK_GOOGLE_USER_TYPE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEUserTypeSpecVersion = VK_GOOGLE_USER_TYPE_SPEC_VERSION;
//=== VK_KHR_pipeline_library ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineLibraryExtensionName = VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineLibrarySpecVersion = VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION;
//=== VK_NV_present_barrier ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentBarrierExtensionName = VK_NV_PRESENT_BARRIER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentBarrierSpecVersion = VK_NV_PRESENT_BARRIER_SPEC_VERSION;
//=== VK_KHR_shader_non_semantic_info ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderNonSemanticInfoExtensionName = VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderNonSemanticInfoSpecVersion = VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION;
//=== VK_KHR_present_id ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentIdExtensionName = VK_KHR_PRESENT_ID_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentIdSpecVersion = VK_KHR_PRESENT_ID_SPEC_VERSION;
//=== VK_EXT_private_data ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrivateDataExtensionName = VK_EXT_PRIVATE_DATA_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrivateDataSpecVersion = VK_EXT_PRIVATE_DATA_SPEC_VERSION;
//=== VK_EXT_pipeline_creation_cache_control ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationCacheControlExtensionName = VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationCacheControlSpecVersion = VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION;
//=== VK_KHR_video_encode_queue ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeQueueExtensionName = VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeQueueSpecVersion = VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION;
//=== VK_NV_device_diagnostics_config ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticsConfigExtensionName = VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticsConfigSpecVersion = VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION;
//=== VK_QCOM_render_pass_store_ops ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassStoreOpsExtensionName = VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassStoreOpsSpecVersion = VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_cuda_kernel_launch ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVCudaKernelLaunchExtensionName = VK_NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVCudaKernelLaunchSpecVersion = VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_NV_low_latency ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatencyExtensionName = VK_NV_LOW_LATENCY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatencySpecVersion = VK_NV_LOW_LATENCY_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_objects ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalObjectsExtensionName = VK_EXT_METAL_OBJECTS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalObjectsSpecVersion = VK_EXT_METAL_OBJECTS_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_synchronization2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSynchronization2ExtensionName = VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSynchronization2SpecVersion = VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION;
//=== VK_EXT_descriptor_buffer ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorBufferExtensionName = VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorBufferSpecVersion = VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION;
//=== VK_EXT_graphics_pipeline_library ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTGraphicsPipelineLibraryExtensionName = VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTGraphicsPipelineLibrarySpecVersion = VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION;
//=== VK_AMD_shader_early_and_late_fragment_tests ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderEarlyAndLateFragmentTestsExtensionName = VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderEarlyAndLateFragmentTestsSpecVersion = VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION;
//=== VK_KHR_fragment_shader_barycentric ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShaderBarycentricExtensionName = VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShaderBarycentricSpecVersion = VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION;
//=== VK_KHR_shader_subgroup_uniform_control_flow ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupUniformControlFlowExtensionName = VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupUniformControlFlowSpecVersion = VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION;
//=== VK_KHR_zero_initialize_workgroup_memory ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRZeroInitializeWorkgroupMemoryExtensionName = VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRZeroInitializeWorkgroupMemorySpecVersion = VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION;
//=== VK_NV_fragment_shading_rate_enums ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShadingRateEnumsExtensionName = VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShadingRateEnumsSpecVersion = VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION;
//=== VK_NV_ray_tracing_motion_blur ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingMotionBlurExtensionName = VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingMotionBlurSpecVersion = VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION;
//=== VK_EXT_mesh_shader ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMeshShaderExtensionName = VK_EXT_MESH_SHADER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMeshShaderSpecVersion = VK_EXT_MESH_SHADER_SPEC_VERSION;
//=== VK_EXT_ycbcr_2plane_444_formats ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcr2Plane444FormatsExtensionName = VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcr2Plane444FormatsSpecVersion = VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION;
//=== VK_EXT_fragment_density_map2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMap2ExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMap2SpecVersion = VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION;
//=== VK_QCOM_rotated_copy_commands ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRotatedCopyCommandsExtensionName = VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRotatedCopyCommandsSpecVersion = VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION;
//=== VK_EXT_image_robustness ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageRobustnessExtensionName = VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageRobustnessSpecVersion = VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION;
//=== VK_KHR_workgroup_memory_explicit_layout ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRWorkgroupMemoryExplicitLayoutExtensionName = VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRWorkgroupMemoryExplicitLayoutSpecVersion = VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION;
//=== VK_KHR_copy_commands2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyCommands2ExtensionName = VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyCommands2SpecVersion = VK_KHR_COPY_COMMANDS_2_SPEC_VERSION;
//=== VK_EXT_image_compression_control ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlExtensionName = VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlSpecVersion = VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION;
//=== VK_EXT_attachment_feedback_loop_layout ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopLayoutExtensionName = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopLayoutSpecVersion = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION;
//=== VK_EXT_4444_formats ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXT4444FormatsExtensionName = VK_EXT_4444_FORMATS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXT4444FormatsSpecVersion = VK_EXT_4444_FORMATS_SPEC_VERSION;
//=== VK_EXT_device_fault ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceFaultExtensionName = VK_EXT_DEVICE_FAULT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceFaultSpecVersion = VK_EXT_DEVICE_FAULT_SPEC_VERSION;
//=== VK_ARM_rasterization_order_attachment_access ===
VULKAN_HPP_CONSTEXPR_INLINE auto ARMRasterizationOrderAttachmentAccessExtensionName = VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto ARMRasterizationOrderAttachmentAccessSpecVersion = VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION;
//=== VK_EXT_rgba10x6_formats ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTRgba10X6FormatsExtensionName = VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTRgba10X6FormatsSpecVersion = VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_acquire_winrt_display ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVAcquireWinrtDisplayExtensionName = VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVAcquireWinrtDisplaySpecVersion = VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
//=== VK_EXT_directfb_surface ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectfbSurfaceExtensionName = VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectfbSurfaceSpecVersion = VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
//=== VK_VALVE_mutable_descriptor_type ===
VULKAN_HPP_CONSTEXPR_INLINE auto VALVEMutableDescriptorTypeExtensionName = VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto VALVEMutableDescriptorTypeSpecVersion = VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION;
//=== VK_EXT_vertex_input_dynamic_state ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexInputDynamicStateExtensionName = VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexInputDynamicStateSpecVersion = VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION;
//=== VK_EXT_physical_device_drm ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPhysicalDeviceDrmExtensionName = VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPhysicalDeviceDrmSpecVersion = VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION;
//=== VK_EXT_device_address_binding_report ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceAddressBindingReportExtensionName = VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceAddressBindingReportSpecVersion = VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION;
//=== VK_EXT_depth_clip_control ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipControlExtensionName = VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipControlSpecVersion = VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION;
//=== VK_EXT_primitive_topology_list_restart ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitiveTopologyListRestartExtensionName = VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitiveTopologyListRestartSpecVersion = VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION;
//=== VK_KHR_format_feature_flags2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRFormatFeatureFlags2ExtensionName = VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRFormatFeatureFlags2SpecVersion = VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_external_memory ===
VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalMemoryExtensionName = VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalMemorySpecVersion = VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_external_semaphore ===
VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalSemaphoreExtensionName = VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalSemaphoreSpecVersion = VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_buffer_collection ===
VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIABufferCollectionExtensionName = VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIABufferCollectionSpecVersion = VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_FUCHSIA*/
//=== VK_HUAWEI_subpass_shading ===
VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEISubpassShadingExtensionName = VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEISubpassShadingSpecVersion = VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION;
//=== VK_HUAWEI_invocation_mask ===
VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIInvocationMaskExtensionName = VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIInvocationMaskSpecVersion = VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION;
//=== VK_NV_external_memory_rdma ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryRdmaExtensionName = VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryRdmaSpecVersion = VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION;
//=== VK_EXT_pipeline_properties ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelinePropertiesExtensionName = VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelinePropertiesSpecVersion = VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION;
//=== VK_EXT_frame_boundary ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFrameBoundaryExtensionName = VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFrameBoundarySpecVersion = VK_EXT_FRAME_BOUNDARY_SPEC_VERSION;
//=== VK_EXT_multisampled_render_to_single_sampled ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultisampledRenderToSingleSampledExtensionName = VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultisampledRenderToSingleSampledSpecVersion = VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION;
//=== VK_EXT_extended_dynamic_state2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState2ExtensionName = VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState2SpecVersion = VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_screen_surface ===
VULKAN_HPP_CONSTEXPR_INLINE auto QNXScreenSurfaceExtensionName = VK_QNX_SCREEN_SURFACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QNXScreenSurfaceSpecVersion = VK_QNX_SCREEN_SURFACE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_EXT_color_write_enable ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTColorWriteEnableExtensionName = VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTColorWriteEnableSpecVersion = VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION;
//=== VK_EXT_primitives_generated_query ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitivesGeneratedQueryExtensionName = VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitivesGeneratedQuerySpecVersion = VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION;
//=== VK_KHR_ray_tracing_maintenance1 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingMaintenance1ExtensionName = VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingMaintenance1SpecVersion = VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION;
//=== VK_EXT_global_priority_query ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityQueryExtensionName = VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityQuerySpecVersion = VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION;
//=== VK_EXT_image_view_min_lod ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageViewMinLodExtensionName = VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageViewMinLodSpecVersion = VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION;
//=== VK_EXT_multi_draw ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultiDrawExtensionName = VK_EXT_MULTI_DRAW_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultiDrawSpecVersion = VK_EXT_MULTI_DRAW_SPEC_VERSION;
//=== VK_EXT_image_2d_view_of_3d ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImage2DViewOf3DExtensionName = VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImage2DViewOf3DSpecVersion = VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION;
//=== VK_KHR_portability_enumeration ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilityEnumerationExtensionName = VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilityEnumerationSpecVersion = VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION;
//=== VK_EXT_shader_tile_image ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderTileImageExtensionName = VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderTileImageSpecVersion = VK_EXT_SHADER_TILE_IMAGE_SPEC_VERSION;
//=== VK_EXT_opacity_micromap ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTOpacityMicromapExtensionName = VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTOpacityMicromapSpecVersion = VK_EXT_OPACITY_MICROMAP_SPEC_VERSION;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_displacement_micromap ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplacementMicromapExtensionName = VK_NV_DISPLACEMENT_MICROMAP_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplacementMicromapSpecVersion = VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_load_store_op_none ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTLoadStoreOpNoneExtensionName = VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTLoadStoreOpNoneSpecVersion = VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION;
//=== VK_HUAWEI_cluster_culling_shader ===
VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIClusterCullingShaderExtensionName = VK_HUAWEI_CLUSTER_CULLING_SHADER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIClusterCullingShaderSpecVersion = VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION;
//=== VK_EXT_border_color_swizzle ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTBorderColorSwizzleExtensionName = VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTBorderColorSwizzleSpecVersion = VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION;
//=== VK_EXT_pageable_device_local_memory ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPageableDeviceLocalMemoryExtensionName = VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPageableDeviceLocalMemorySpecVersion = VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION;
//=== VK_KHR_maintenance4 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance4ExtensionName = VK_KHR_MAINTENANCE_4_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance4SpecVersion = VK_KHR_MAINTENANCE_4_SPEC_VERSION;
//=== VK_ARM_shader_core_properties ===
VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCorePropertiesExtensionName = VK_ARM_SHADER_CORE_PROPERTIES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCorePropertiesSpecVersion = VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION;
//=== VK_KHR_shader_subgroup_rotate ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupRotateExtensionName = VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupRotateSpecVersion = VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION;
//=== VK_ARM_scheduling_controls ===
VULKAN_HPP_CONSTEXPR_INLINE auto ARMSchedulingControlsExtensionName = VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto ARMSchedulingControlsSpecVersion = VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION;
//=== VK_EXT_image_sliced_view_of_3d ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageSlicedViewOf3DExtensionName = VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageSlicedViewOf3DSpecVersion = VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION;
//=== VK_VALVE_descriptor_set_host_mapping ===
VULKAN_HPP_CONSTEXPR_INLINE auto VALVEDescriptorSetHostMappingExtensionName = VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto VALVEDescriptorSetHostMappingSpecVersion = VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION;
//=== VK_EXT_depth_clamp_zero_one ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampZeroOneExtensionName = VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampZeroOneSpecVersion = VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION;
//=== VK_EXT_non_seamless_cube_map ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTNonSeamlessCubeMapExtensionName = VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTNonSeamlessCubeMapSpecVersion = VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION;
//=== VK_ARM_render_pass_striped ===
VULKAN_HPP_CONSTEXPR_INLINE auto ARMRenderPassStripedExtensionName = VK_ARM_RENDER_PASS_STRIPED_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto ARMRenderPassStripedSpecVersion = VK_ARM_RENDER_PASS_STRIPED_SPEC_VERSION;
//=== VK_QCOM_fragment_density_map_offset ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFragmentDensityMapOffsetExtensionName = VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFragmentDensityMapOffsetSpecVersion = VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION;
//=== VK_NV_copy_memory_indirect ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVCopyMemoryIndirectExtensionName = VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVCopyMemoryIndirectSpecVersion = VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION;
//=== VK_NV_memory_decompression ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVMemoryDecompressionExtensionName = VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVMemoryDecompressionSpecVersion = VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION;
//=== VK_NV_device_generated_commands_compute ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsComputeExtensionName = VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsComputeSpecVersion = VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_SPEC_VERSION;
//=== VK_NV_linear_color_attachment ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVLinearColorAttachmentExtensionName = VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVLinearColorAttachmentSpecVersion = VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION;
//=== VK_GOOGLE_surfaceless_query ===
VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLESurfacelessQueryExtensionName = VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLESurfacelessQuerySpecVersion = VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION;
//=== VK_KHR_shader_maximal_reconvergence ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderMaximalReconvergenceExtensionName = VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderMaximalReconvergenceSpecVersion = VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION;
//=== VK_EXT_image_compression_control_swapchain ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlSwapchainExtensionName = VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlSwapchainSpecVersion = VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION;
//=== VK_QCOM_image_processing ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessingExtensionName = VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessingSpecVersion = VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION;
//=== VK_EXT_nested_command_buffer ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTNestedCommandBufferExtensionName = VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTNestedCommandBufferSpecVersion = VK_EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION;
//=== VK_EXT_external_memory_acquire_unmodified ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryAcquireUnmodifiedExtensionName = VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryAcquireUnmodifiedSpecVersion = VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION;
//=== VK_EXT_extended_dynamic_state3 ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState3ExtensionName = VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState3SpecVersion = VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION;
//=== VK_EXT_subpass_merge_feedback ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubpassMergeFeedbackExtensionName = VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubpassMergeFeedbackSpecVersion = VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION;
//=== VK_LUNARG_direct_driver_loading ===
VULKAN_HPP_CONSTEXPR_INLINE auto LUNARGDirectDriverLoadingExtensionName = VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto LUNARGDirectDriverLoadingSpecVersion = VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION;
//=== VK_EXT_shader_module_identifier ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderModuleIdentifierExtensionName = VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderModuleIdentifierSpecVersion = VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION;
//=== VK_EXT_rasterization_order_attachment_access ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTRasterizationOrderAttachmentAccessExtensionName = VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTRasterizationOrderAttachmentAccessSpecVersion = VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION;
//=== VK_NV_optical_flow ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVOpticalFlowExtensionName = VK_NV_OPTICAL_FLOW_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVOpticalFlowSpecVersion = VK_NV_OPTICAL_FLOW_SPEC_VERSION;
//=== VK_EXT_legacy_dithering ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyDitheringExtensionName = VK_EXT_LEGACY_DITHERING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyDitheringSpecVersion = VK_EXT_LEGACY_DITHERING_SPEC_VERSION;
//=== VK_EXT_pipeline_protected_access ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineProtectedAccessExtensionName = VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineProtectedAccessSpecVersion = VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_ANDROID_external_format_resolve ===
VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalFormatResolveExtensionName = VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalFormatResolveSpecVersion = VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
//=== VK_KHR_maintenance5 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance5ExtensionName = VK_KHR_MAINTENANCE_5_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance5SpecVersion = VK_KHR_MAINTENANCE_5_SPEC_VERSION;
//=== VK_AMD_anti_lag ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDAntiLagExtensionName = VK_AMD_ANTI_LAG_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDAntiLagSpecVersion = VK_AMD_ANTI_LAG_SPEC_VERSION;
//=== VK_KHR_ray_tracing_position_fetch ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPositionFetchExtensionName = VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPositionFetchSpecVersion = VK_KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION;
//=== VK_EXT_shader_object ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderObjectExtensionName = VK_EXT_SHADER_OBJECT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderObjectSpecVersion = VK_EXT_SHADER_OBJECT_SPEC_VERSION;
//=== VK_QCOM_tile_properties ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTilePropertiesExtensionName = VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTilePropertiesSpecVersion = VK_QCOM_TILE_PROPERTIES_SPEC_VERSION;
//=== VK_SEC_amigo_profiling ===
VULKAN_HPP_CONSTEXPR_INLINE auto SECAmigoProfilingExtensionName = VK_SEC_AMIGO_PROFILING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto SECAmigoProfilingSpecVersion = VK_SEC_AMIGO_PROFILING_SPEC_VERSION;
//=== VK_QCOM_multiview_per_view_viewports ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewViewportsExtensionName = VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewViewportsSpecVersion = VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION;
//=== VK_NV_ray_tracing_invocation_reorder ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingInvocationReorderExtensionName = VK_NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingInvocationReorderSpecVersion = VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION;
//=== VK_NV_extended_sparse_address_space ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVExtendedSparseAddressSpaceExtensionName = VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVExtendedSparseAddressSpaceSpecVersion = VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION;
//=== VK_EXT_mutable_descriptor_type ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMutableDescriptorTypeExtensionName = VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTMutableDescriptorTypeSpecVersion = VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION;
//=== VK_EXT_legacy_vertex_attributes ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyVertexAttributesExtensionName = VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyVertexAttributesSpecVersion = VK_EXT_LEGACY_VERTEX_ATTRIBUTES_SPEC_VERSION;
//=== VK_EXT_layer_settings ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTLayerSettingsExtensionName = VK_EXT_LAYER_SETTINGS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTLayerSettingsSpecVersion = VK_EXT_LAYER_SETTINGS_SPEC_VERSION;
//=== VK_ARM_shader_core_builtins ===
VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCoreBuiltinsExtensionName = VK_ARM_SHADER_CORE_BUILTINS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCoreBuiltinsSpecVersion = VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION;
//=== VK_EXT_pipeline_library_group_handles ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineLibraryGroupHandlesExtensionName = VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineLibraryGroupHandlesSpecVersion = VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION;
//=== VK_EXT_dynamic_rendering_unused_attachments ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDynamicRenderingUnusedAttachmentsExtensionName = VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDynamicRenderingUnusedAttachmentsSpecVersion = VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION;
//=== VK_NV_low_latency2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatency2ExtensionName = VK_NV_LOW_LATENCY_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatency2SpecVersion = VK_NV_LOW_LATENCY_2_SPEC_VERSION;
//=== VK_KHR_cooperative_matrix ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRCooperativeMatrixExtensionName = VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRCooperativeMatrixSpecVersion = VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION;
//=== VK_QCOM_multiview_per_view_render_areas ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewRenderAreasExtensionName = VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewRenderAreasSpecVersion = VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION;
//=== VK_KHR_video_decode_av1 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeAv1ExtensionName = VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeAv1SpecVersion = VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION;
//=== VK_KHR_video_maintenance1 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance1ExtensionName = VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance1SpecVersion = VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION;
//=== VK_NV_per_stage_descriptor_set ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVPerStageDescriptorSetExtensionName = VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVPerStageDescriptorSetSpecVersion = VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION;
//=== VK_QCOM_image_processing2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessing2ExtensionName = VK_QCOM_IMAGE_PROCESSING_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessing2SpecVersion = VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION;
//=== VK_QCOM_filter_cubic_weights ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicWeightsExtensionName = VK_QCOM_FILTER_CUBIC_WEIGHTS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicWeightsSpecVersion = VK_QCOM_FILTER_CUBIC_WEIGHTS_SPEC_VERSION;
//=== VK_QCOM_ycbcr_degamma ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMYcbcrDegammaExtensionName = VK_QCOM_YCBCR_DEGAMMA_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMYcbcrDegammaSpecVersion = VK_QCOM_YCBCR_DEGAMMA_SPEC_VERSION;
//=== VK_QCOM_filter_cubic_clamp ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicClampExtensionName = VK_QCOM_FILTER_CUBIC_CLAMP_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicClampSpecVersion = VK_QCOM_FILTER_CUBIC_CLAMP_SPEC_VERSION;
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopDynamicStateExtensionName = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopDynamicStateSpecVersion = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION;
//=== VK_KHR_vertex_attribute_divisor ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVertexAttributeDivisorExtensionName = VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVertexAttributeDivisorSpecVersion = VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION;
//=== VK_KHR_load_store_op_none ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRLoadStoreOpNoneExtensionName = VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRLoadStoreOpNoneSpecVersion = VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION;
//=== VK_KHR_shader_float_controls2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControls2ExtensionName = VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControls2SpecVersion = VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_external_memory_screen_buffer ===
VULKAN_HPP_CONSTEXPR_INLINE auto QNXExternalMemoryScreenBufferExtensionName = VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QNXExternalMemoryScreenBufferSpecVersion = VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_MSFT_layered_driver ===
VULKAN_HPP_CONSTEXPR_INLINE auto MSFTLayeredDriverExtensionName = VK_MSFT_LAYERED_DRIVER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto MSFTLayeredDriverSpecVersion = VK_MSFT_LAYERED_DRIVER_SPEC_VERSION;
//=== VK_KHR_index_type_uint8 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRIndexTypeUint8ExtensionName = VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRIndexTypeUint8SpecVersion = VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION;
//=== VK_KHR_line_rasterization ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRLineRasterizationExtensionName = VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRLineRasterizationSpecVersion = VK_KHR_LINE_RASTERIZATION_SPEC_VERSION;
//=== VK_KHR_calibrated_timestamps ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRCalibratedTimestampsExtensionName = VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRCalibratedTimestampsSpecVersion = VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION;
//=== VK_KHR_shader_expect_assume ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderExpectAssumeExtensionName = VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderExpectAssumeSpecVersion = VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION;
//=== VK_KHR_maintenance6 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance6ExtensionName = VK_KHR_MAINTENANCE_6_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance6SpecVersion = VK_KHR_MAINTENANCE_6_SPEC_VERSION;
//=== VK_NV_descriptor_pool_overallocation ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationExtensionName = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationSpecVersion = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION;
//=== VK_NV_raw_access_chains ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsExtensionName = VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsSpecVersion = VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION;
//=== VK_KHR_shader_relaxed_extended_instruction ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionExtensionName = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionSpecVersion = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION;
//=== VK_NV_command_buffer_inheritance ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVCommandBufferInheritanceExtensionName = VK_NV_COMMAND_BUFFER_INHERITANCE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVCommandBufferInheritanceSpecVersion = VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION;
//=== VK_KHR_maintenance7 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance7ExtensionName = VK_KHR_MAINTENANCE_7_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance7SpecVersion = VK_KHR_MAINTENANCE_7_SPEC_VERSION;
//=== VK_NV_shader_atomic_float16_vector ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorExtensionName = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorSpecVersion = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION;
//=== VK_EXT_shader_replicated_composites ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderReplicatedCompositesExtensionName = VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderReplicatedCompositesSpecVersion = VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION;
//=== VK_NV_ray_tracing_validation ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationExtensionName = VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationSpecVersion = VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION;
//=== VK_MESA_image_alignment_control ===
VULKAN_HPP_CONSTEXPR_INLINE auto MESAImageAlignmentControlExtensionName = VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto MESAImageAlignmentControlSpecVersion = VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION;
} // namespace VULKAN_HPP_NAMESPACE
// clang-format off
#include <vulkan/vulkan_handles.hpp>
#include <vulkan/vulkan_structs.hpp>
#include <vulkan/vulkan_funcs.hpp>
// clang-format on
namespace VULKAN_HPP_NAMESPACE
{
#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
//=======================
//=== STRUCTS EXTENDS ===
//=======================
//=== VK_VERSION_1_0 ===
template <>
struct StructExtends<ShaderModuleCreateInfo, PipelineShaderStageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineLayoutCreateInfo, BindDescriptorSetsInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineLayoutCreateInfo, PushConstantsInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineLayoutCreateInfo, PushDescriptorSetInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineLayoutCreateInfo, PushDescriptorSetWithTemplateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineLayoutCreateInfo, SetDescriptorBufferOffsetsInfoEXT>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineLayoutCreateInfo, BindDescriptorBufferEmbeddedSamplersInfoEXT>
{
enum
{
value = true
};
};
//=== VK_VERSION_1_1 ===
template <>
struct StructExtends<PhysicalDeviceSubgroupProperties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevice16BitStorageFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevice16BitStorageFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MemoryDedicatedRequirements, MemoryRequirements2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MemoryDedicatedAllocateInfo, MemoryAllocateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MemoryAllocateFlagsInfo, MemoryAllocateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderPassBeginInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderingInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DeviceGroupCommandBufferBeginInfo, CommandBufferBeginInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DeviceGroupSubmitInfo, SubmitInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DeviceGroupBindSparseInfo, BindSparseInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<BindBufferMemoryDeviceGroupInfo, BindBufferMemoryInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<BindImageMemoryDeviceGroupInfo, BindImageMemoryInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DeviceGroupDeviceCreateInfo, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFeatures2, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePointClippingProperties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassInputAttachmentAspectCreateInfo, RenderPassCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageViewUsageCreateInfo, ImageViewCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineTessellationDomainOriginStateCreateInfo, PipelineTessellationStateCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassMultiviewCreateInfo, RenderPassCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMultiviewFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMultiviewFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMultiviewProperties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVariablePointersFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVariablePointersFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceProtectedMemoryProperties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ProtectedSubmitInfo, SubmitInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SamplerYcbcrConversionInfo, SamplerCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SamplerYcbcrConversionInfo, ImageViewCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<BindImagePlaneMemoryInfo, BindImageMemoryInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImagePlaneMemoryRequirementsInfo, ImageMemoryRequirementsInfo2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SamplerYcbcrConversionImageFormatProperties, ImageFormatProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceExternalImageFormatInfo, PhysicalDeviceImageFormatInfo2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExternalImageFormatProperties, ImageFormatProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceIDProperties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExternalMemoryImageCreateInfo, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExternalMemoryBufferCreateInfo, BufferCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMemoryAllocateInfo, MemoryAllocateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportFenceCreateInfo, FenceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportSemaphoreCreateInfo, SemaphoreCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance3Properties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_VERSION_1_2 ===
template <>
struct StructExtends<PhysicalDeviceVulkan11Features, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVulkan11Features, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVulkan11Properties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVulkan12Features, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVulkan12Features, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVulkan12Properties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageFormatListCreateInfo, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageFormatListCreateInfo, SwapchainCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageFormatListCreateInfo, PhysicalDeviceImageFormatInfo2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevice8BitStorageFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevice8BitStorageFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDriverProperties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFloatControlsProperties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DescriptorSetLayoutBindingFlagsCreateInfo, DescriptorSetLayoutCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDescriptorIndexingProperties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DescriptorSetVariableDescriptorCountAllocateInfo, DescriptorSetAllocateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DescriptorSetVariableDescriptorCountLayoutSupport, DescriptorSetLayoutSupport>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SubpassDescriptionDepthStencilResolve, SubpassDescription2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDepthStencilResolveProperties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageStencilUsageCreateInfo, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageStencilUsageCreateInfo, PhysicalDeviceImageFormatInfo2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SamplerReductionModeCreateInfo, SamplerCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSamplerFilterMinmaxProperties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<FramebufferAttachmentsCreateInfo, FramebufferCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassAttachmentBeginInfo, RenderPassBeginInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<AttachmentReferenceStencilLayout, AttachmentReference2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<AttachmentDescriptionStencilLayout, AttachmentDescription2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceHostQueryResetFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceHostQueryResetFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceTimelineSemaphoreProperties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SemaphoreTypeCreateInfo, SemaphoreCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SemaphoreTypeCreateInfo, PhysicalDeviceExternalSemaphoreInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<TimelineSemaphoreSubmitInfo, SubmitInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<TimelineSemaphoreSubmitInfo, BindSparseInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<BufferOpaqueCaptureAddressCreateInfo, BufferCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MemoryOpaqueCaptureAddressAllocateInfo, MemoryAllocateInfo>
{
enum
{
value = true
};
};
//=== VK_VERSION_1_3 ===
template <>
struct StructExtends<PhysicalDeviceVulkan13Features, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVulkan13Features, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVulkan13Properties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineCreationFeedbackCreateInfo, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineCreationFeedbackCreateInfo, ComputePipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineCreationFeedbackCreateInfo, RayTracingPipelineCreateInfoNV>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineCreationFeedbackCreateInfo, RayTracingPipelineCreateInfoKHR>
{
enum
{
value = true
};
};
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <>
struct StructExtends<PipelineCreationFeedbackCreateInfo, ExecutionGraphPipelineCreateInfoAMDX>
{
enum
{
value = true
};
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
template <>
struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePrivateDataFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePrivateDataFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DevicePrivateDataCreateInfo, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MemoryBarrier2, SubpassDependency2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSynchronization2Features, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSynchronization2Features, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageRobustnessFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageRobustnessFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSubgroupSizeControlFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSubgroupSizeControlFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSubgroupSizeControlProperties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineShaderStageRequiredSubgroupSizeCreateInfo, PipelineShaderStageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineShaderStageRequiredSubgroupSizeCreateInfo, ShaderCreateInfoEXT>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceInlineUniformBlockFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceInlineUniformBlockFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceInlineUniformBlockProperties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<WriteDescriptorSetInlineUniformBlock, WriteDescriptorSet>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DescriptorPoolInlineUniformBlockCreateInfo, DescriptorPoolCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineRenderingCreateInfo, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDynamicRenderingFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDynamicRenderingFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<CommandBufferInheritanceRenderingInfo, CommandBufferInheritanceInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeatures, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeatures, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderIntegerDotProductProperties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceTexelBufferAlignmentProperties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<FormatProperties3, FormatProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance4Features, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance4Features, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance4Properties, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_KHR_swapchain ===
template <>
struct StructExtends<ImageSwapchainCreateInfoKHR, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<BindImageMemorySwapchainInfoKHR, BindImageMemoryInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DeviceGroupPresentInfoKHR, PresentInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DeviceGroupSwapchainCreateInfoKHR, SwapchainCreateInfoKHR>
{
enum
{
value = true
};
};
//=== VK_KHR_display_swapchain ===
template <>
struct StructExtends<DisplayPresentInfoKHR, PresentInfoKHR>
{
enum
{
value = true
};
};
//=== VK_EXT_debug_report ===
template <>
struct StructExtends<DebugReportCallbackCreateInfoEXT, InstanceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_AMD_rasterization_order ===
template <>
struct StructExtends<PipelineRasterizationStateRasterizationOrderAMD, PipelineRasterizationStateCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_video_queue ===
template <>
struct StructExtends<QueueFamilyQueryResultStatusPropertiesKHR, QueueFamilyProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<QueueFamilyVideoPropertiesKHR, QueueFamilyProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoProfileInfoKHR, QueryPoolCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoProfileListInfoKHR, PhysicalDeviceImageFormatInfo2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoProfileListInfoKHR, PhysicalDeviceVideoFormatInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoProfileListInfoKHR, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoProfileListInfoKHR, BufferCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_video_decode_queue ===
template <>
struct StructExtends<VideoDecodeCapabilitiesKHR, VideoCapabilitiesKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeUsageInfoKHR, VideoProfileInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeUsageInfoKHR, QueryPoolCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_dedicated_allocation ===
template <>
struct StructExtends<DedicatedAllocationImageCreateInfoNV, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DedicatedAllocationBufferCreateInfoNV, BufferCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DedicatedAllocationMemoryAllocateInfoNV, MemoryAllocateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_transform_feedback ===
template <>
struct StructExtends<PhysicalDeviceTransformFeedbackFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceTransformFeedbackFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceTransformFeedbackPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineRasterizationStateStreamCreateInfoEXT, PipelineRasterizationStateCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_video_encode_h264 ===
template <>
struct StructExtends<VideoEncodeH264CapabilitiesKHR, VideoCapabilitiesKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH264QualityLevelPropertiesKHR, VideoEncodeQualityLevelPropertiesKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH264SessionCreateInfoKHR, VideoSessionCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH264SessionParametersCreateInfoKHR, VideoSessionParametersCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH264SessionParametersAddInfoKHR, VideoSessionParametersUpdateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH264SessionParametersGetInfoKHR, VideoEncodeSessionParametersGetInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH264SessionParametersFeedbackInfoKHR, VideoEncodeSessionParametersFeedbackInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH264PictureInfoKHR, VideoEncodeInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH264DpbSlotInfoKHR, VideoReferenceSlotInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH264ProfileInfoKHR, VideoProfileInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH264ProfileInfoKHR, QueryPoolCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH264RateControlInfoKHR, VideoCodingControlInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH264RateControlInfoKHR, VideoBeginCodingInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH264RateControlLayerInfoKHR, VideoEncodeRateControlLayerInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH264GopRemainingFrameInfoKHR, VideoBeginCodingInfoKHR>
{
enum
{
value = true
};
};
//=== VK_KHR_video_encode_h265 ===
template <>
struct StructExtends<VideoEncodeH265CapabilitiesKHR, VideoCapabilitiesKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH265SessionCreateInfoKHR, VideoSessionCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH265QualityLevelPropertiesKHR, VideoEncodeQualityLevelPropertiesKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH265SessionParametersCreateInfoKHR, VideoSessionParametersCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH265SessionParametersAddInfoKHR, VideoSessionParametersUpdateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH265SessionParametersGetInfoKHR, VideoEncodeSessionParametersGetInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH265SessionParametersFeedbackInfoKHR, VideoEncodeSessionParametersFeedbackInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH265PictureInfoKHR, VideoEncodeInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH265DpbSlotInfoKHR, VideoReferenceSlotInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH265ProfileInfoKHR, VideoProfileInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH265ProfileInfoKHR, QueryPoolCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH265RateControlInfoKHR, VideoCodingControlInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH265RateControlInfoKHR, VideoBeginCodingInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH265RateControlLayerInfoKHR, VideoEncodeRateControlLayerInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeH265GopRemainingFrameInfoKHR, VideoBeginCodingInfoKHR>
{
enum
{
value = true
};
};
//=== VK_KHR_video_decode_h264 ===
template <>
struct StructExtends<VideoDecodeH264ProfileInfoKHR, VideoProfileInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeH264ProfileInfoKHR, QueryPoolCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeH264CapabilitiesKHR, VideoCapabilitiesKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeH264SessionParametersCreateInfoKHR, VideoSessionParametersCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeH264SessionParametersAddInfoKHR, VideoSessionParametersUpdateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeH264PictureInfoKHR, VideoDecodeInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeH264DpbSlotInfoKHR, VideoReferenceSlotInfoKHR>
{
enum
{
value = true
};
};
//=== VK_AMD_texture_gather_bias_lod ===
template <>
struct StructExtends<TextureLODGatherFormatPropertiesAMD, ImageFormatProperties2>
{
enum
{
value = true
};
};
//=== VK_KHR_dynamic_rendering ===
template <>
struct StructExtends<RenderingFragmentShadingRateAttachmentInfoKHR, RenderingInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderingFragmentDensityMapAttachmentInfoEXT, RenderingInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<AttachmentSampleCountInfoAMD, CommandBufferInheritanceInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<AttachmentSampleCountInfoAMD, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MultiviewPerViewAttributesInfoNVX, CommandBufferInheritanceInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MultiviewPerViewAttributesInfoNVX, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MultiviewPerViewAttributesInfoNVX, RenderingInfo>
{
enum
{
value = true
};
};
//=== VK_NV_corner_sampled_image ===
template <>
struct StructExtends<PhysicalDeviceCornerSampledImageFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCornerSampledImageFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_external_memory ===
template <>
struct StructExtends<ExternalMemoryImageCreateInfoNV, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMemoryAllocateInfoNV, MemoryAllocateInfo>
{
enum
{
value = true
};
};
# if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_external_memory_win32 ===
template <>
struct StructExtends<ImportMemoryWin32HandleInfoNV, MemoryAllocateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMemoryWin32HandleInfoNV, MemoryAllocateInfo>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
# if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_win32_keyed_mutex ===
template <>
struct StructExtends<Win32KeyedMutexAcquireReleaseInfoNV, SubmitInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<Win32KeyedMutexAcquireReleaseInfoNV, SubmitInfo2>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_validation_flags ===
template <>
struct StructExtends<ValidationFlagsEXT, InstanceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_astc_decode_mode ===
template <>
struct StructExtends<ImageViewASTCDecodeModeEXT, ImageViewCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceASTCDecodeFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceASTCDecodeFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_pipeline_robustness ===
template <>
struct StructExtends<PhysicalDevicePipelineRobustnessFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePipelineRobustnessFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePipelineRobustnessPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineRobustnessCreateInfoEXT, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineRobustnessCreateInfoEXT, ComputePipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineRobustnessCreateInfoEXT, PipelineShaderStageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineRobustnessCreateInfoEXT, RayTracingPipelineCreateInfoKHR>
{
enum
{
value = true
};
};
# if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_memory_win32 ===
template <>
struct StructExtends<ImportMemoryWin32HandleInfoKHR, MemoryAllocateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMemoryWin32HandleInfoKHR, MemoryAllocateInfo>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_memory_fd ===
template <>
struct StructExtends<ImportMemoryFdInfoKHR, MemoryAllocateInfo>
{
enum
{
value = true
};
};
# if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_win32_keyed_mutex ===
template <>
struct StructExtends<Win32KeyedMutexAcquireReleaseInfoKHR, SubmitInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<Win32KeyedMutexAcquireReleaseInfoKHR, SubmitInfo2>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
# if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_semaphore_win32 ===
template <>
struct StructExtends<ExportSemaphoreWin32HandleInfoKHR, SemaphoreCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<D3D12FenceSubmitInfoKHR, SubmitInfo>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_push_descriptor ===
template <>
struct StructExtends<PhysicalDevicePushDescriptorPropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_conditional_rendering ===
template <>
struct StructExtends<PhysicalDeviceConditionalRenderingFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceConditionalRenderingFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<CommandBufferInheritanceConditionalRenderingInfoEXT, CommandBufferInheritanceInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_incremental_present ===
template <>
struct StructExtends<PresentRegionsKHR, PresentInfoKHR>
{
enum
{
value = true
};
};
//=== VK_NV_clip_space_w_scaling ===
template <>
struct StructExtends<PipelineViewportWScalingStateCreateInfoNV, PipelineViewportStateCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_display_control ===
template <>
struct StructExtends<SwapchainCounterCreateInfoEXT, SwapchainCreateInfoKHR>
{
enum
{
value = true
};
};
//=== VK_GOOGLE_display_timing ===
template <>
struct StructExtends<PresentTimesInfoGOOGLE, PresentInfoKHR>
{
enum
{
value = true
};
};
//=== VK_NVX_multiview_per_view_attributes ===
template <>
struct StructExtends<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_NV_viewport_swizzle ===
template <>
struct StructExtends<PipelineViewportSwizzleStateCreateInfoNV, PipelineViewportStateCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_discard_rectangles ===
template <>
struct StructExtends<PhysicalDeviceDiscardRectanglePropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineDiscardRectangleStateCreateInfoEXT, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_conservative_rasterization ===
template <>
struct StructExtends<PhysicalDeviceConservativeRasterizationPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineRasterizationConservativeStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_depth_clip_enable ===
template <>
struct StructExtends<PhysicalDeviceDepthClipEnableFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDepthClipEnableFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineRasterizationDepthClipStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>
{
enum
{
value = true
};
};
//=== VK_IMG_relaxed_line_rasterization ===
template <>
struct StructExtends<PhysicalDeviceRelaxedLineRasterizationFeaturesIMG, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRelaxedLineRasterizationFeaturesIMG, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_shared_presentable_image ===
template <>
struct StructExtends<SharedPresentSurfaceCapabilitiesKHR, SurfaceCapabilities2KHR>
{
enum
{
value = true
};
};
# if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_fence_win32 ===
template <>
struct StructExtends<ExportFenceWin32HandleInfoKHR, FenceCreateInfo>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_performance_query ===
template <>
struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePerformanceQueryPropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<QueryPoolPerformanceCreateInfoKHR, QueryPoolCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo2>
{
enum
{
value = true
};
};
//=== VK_EXT_debug_utils ===
template <>
struct StructExtends<DebugUtilsMessengerCreateInfoEXT, InstanceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DebugUtilsObjectNameInfoEXT, PipelineShaderStageCreateInfo>
{
enum
{
value = true
};
};
# if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_ANDROID_external_memory_android_hardware_buffer ===
template <>
struct StructExtends<AndroidHardwareBufferUsageANDROID, ImageFormatProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<AndroidHardwareBufferFormatPropertiesANDROID, AndroidHardwareBufferPropertiesANDROID>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImportAndroidHardwareBufferInfoANDROID, MemoryAllocateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExternalFormatANDROID, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExternalFormatANDROID, SamplerYcbcrConversionCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExternalFormatANDROID, AttachmentDescription2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExternalFormatANDROID, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExternalFormatANDROID, CommandBufferInheritanceInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<AndroidHardwareBufferFormatProperties2ANDROID, AndroidHardwareBufferPropertiesANDROID>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
# if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_shader_enqueue ===
template <>
struct StructExtends<PhysicalDeviceShaderEnqueueFeaturesAMDX, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderEnqueueFeaturesAMDX, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderEnqueuePropertiesAMDX, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineShaderStageNodeCreateInfoAMDX, PipelineShaderStageCreateInfo>
{
enum
{
value = true
};
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_sample_locations ===
template <>
struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassSampleLocationsBeginInfoEXT, RenderPassBeginInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineSampleLocationsStateCreateInfoEXT, PipelineMultisampleStateCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSampleLocationsPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_blend_operation_advanced ===
template <>
struct StructExtends<PhysicalDeviceBlendOperationAdvancedFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceBlendOperationAdvancedFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceBlendOperationAdvancedPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineColorBlendAdvancedStateCreateInfoEXT, PipelineColorBlendStateCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_fragment_coverage_to_color ===
template <>
struct StructExtends<PipelineCoverageToColorStateCreateInfoNV, PipelineMultisampleStateCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_acceleration_structure ===
template <>
struct StructExtends<WriteDescriptorSetAccelerationStructureKHR, WriteDescriptorSet>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceAccelerationStructureFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceAccelerationStructureFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceAccelerationStructurePropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_KHR_ray_tracing_pipeline ===
template <>
struct StructExtends<PhysicalDeviceRayTracingPipelineFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRayTracingPipelineFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRayTracingPipelinePropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_KHR_ray_query ===
template <>
struct StructExtends<PhysicalDeviceRayQueryFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRayQueryFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_framebuffer_mixed_samples ===
template <>
struct StructExtends<PipelineCoverageModulationStateCreateInfoNV, PipelineMultisampleStateCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_shader_sm_builtins ===
template <>
struct StructExtends<PhysicalDeviceShaderSMBuiltinsPropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderSMBuiltinsFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderSMBuiltinsFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_image_drm_format_modifier ===
template <>
struct StructExtends<DrmFormatModifierPropertiesListEXT, FormatProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageDrmFormatModifierInfoEXT, PhysicalDeviceImageFormatInfo2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageDrmFormatModifierListCreateInfoEXT, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageDrmFormatModifierExplicitCreateInfoEXT, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DrmFormatModifierPropertiesList2EXT, FormatProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_validation_cache ===
template <>
struct StructExtends<ShaderModuleValidationCacheCreateInfoEXT, ShaderModuleCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ShaderModuleValidationCacheCreateInfoEXT, PipelineShaderStageCreateInfo>
{
enum
{
value = true
};
};
# if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_portability_subset ===
template <>
struct StructExtends<PhysicalDevicePortabilitySubsetFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePortabilitySubsetFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePortabilitySubsetPropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_NV_shading_rate_image ===
template <>
struct StructExtends<PipelineViewportShadingRateImageStateCreateInfoNV, PipelineViewportStateCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShadingRateImageFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShadingRateImageFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShadingRateImagePropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineViewportCoarseSampleOrderStateCreateInfoNV, PipelineViewportStateCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_ray_tracing ===
template <>
struct StructExtends<WriteDescriptorSetAccelerationStructureNV, WriteDescriptorSet>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRayTracingPropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_NV_representative_fragment_test ===
template <>
struct StructExtends<PhysicalDeviceRepresentativeFragmentTestFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRepresentativeFragmentTestFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineRepresentativeFragmentTestStateCreateInfoNV, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_filter_cubic ===
template <>
struct StructExtends<PhysicalDeviceImageViewImageFormatInfoEXT, PhysicalDeviceImageFormatInfo2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<FilterCubicImageViewImageFormatPropertiesEXT, ImageFormatProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_external_memory_host ===
template <>
struct StructExtends<ImportMemoryHostPointerInfoEXT, MemoryAllocateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceExternalMemoryHostPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_KHR_shader_clock ===
template <>
struct StructExtends<PhysicalDeviceShaderClockFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderClockFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_AMD_pipeline_compiler_control ===
template <>
struct StructExtends<PipelineCompilerControlCreateInfoAMD, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineCompilerControlCreateInfoAMD, ComputePipelineCreateInfo>
{
enum
{
value = true
};
};
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <>
struct StructExtends<PipelineCompilerControlCreateInfoAMD, ExecutionGraphPipelineCreateInfoAMDX>
{
enum
{
value = true
};
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_AMD_shader_core_properties ===
template <>
struct StructExtends<PhysicalDeviceShaderCorePropertiesAMD, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_KHR_video_decode_h265 ===
template <>
struct StructExtends<VideoDecodeH265ProfileInfoKHR, VideoProfileInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeH265ProfileInfoKHR, QueryPoolCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeH265CapabilitiesKHR, VideoCapabilitiesKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeH265SessionParametersCreateInfoKHR, VideoSessionParametersCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeH265SessionParametersAddInfoKHR, VideoSessionParametersUpdateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeH265PictureInfoKHR, VideoDecodeInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeH265DpbSlotInfoKHR, VideoReferenceSlotInfoKHR>
{
enum
{
value = true
};
};
//=== VK_KHR_global_priority ===
template <>
struct StructExtends<DeviceQueueGlobalPriorityCreateInfoKHR, DeviceQueueCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceGlobalPriorityQueryFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceGlobalPriorityQueryFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<QueueFamilyGlobalPriorityPropertiesKHR, QueueFamilyProperties2>
{
enum
{
value = true
};
};
//=== VK_AMD_memory_overallocation_behavior ===
template <>
struct StructExtends<DeviceMemoryOverallocationCreateInfoAMD, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_vertex_attribute_divisor ===
template <>
struct StructExtends<PhysicalDeviceVertexAttributeDivisorPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
# if defined( VK_USE_PLATFORM_GGP )
//=== VK_GGP_frame_token ===
template <>
struct StructExtends<PresentFrameTokenGGP, PresentInfoKHR>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_GGP*/
//=== VK_NV_compute_shader_derivatives ===
template <>
struct StructExtends<PhysicalDeviceComputeShaderDerivativesFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceComputeShaderDerivativesFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_mesh_shader ===
template <>
struct StructExtends<PhysicalDeviceMeshShaderFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMeshShaderFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMeshShaderPropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_NV_shader_image_footprint ===
template <>
struct StructExtends<PhysicalDeviceShaderImageFootprintFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderImageFootprintFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_scissor_exclusive ===
template <>
struct StructExtends<PipelineViewportExclusiveScissorStateCreateInfoNV, PipelineViewportStateCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceExclusiveScissorFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceExclusiveScissorFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_device_diagnostic_checkpoints ===
template <>
struct StructExtends<QueueFamilyCheckpointPropertiesNV, QueueFamilyProperties2>
{
enum
{
value = true
};
};
//=== VK_INTEL_shader_integer_functions2 ===
template <>
struct StructExtends<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_INTEL_performance_query ===
template <>
struct StructExtends<QueryPoolPerformanceQueryCreateInfoINTEL, QueryPoolCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_pci_bus_info ===
template <>
struct StructExtends<PhysicalDevicePCIBusInfoPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_AMD_display_native_hdr ===
template <>
struct StructExtends<DisplayNativeHdrSurfaceCapabilitiesAMD, SurfaceCapabilities2KHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SwapchainDisplayNativeHdrCreateInfoAMD, SwapchainCreateInfoKHR>
{
enum
{
value = true
};
};
//=== VK_EXT_fragment_density_map ===
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassFragmentDensityMapCreateInfoEXT, RenderPassCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassFragmentDensityMapCreateInfoEXT, RenderPassCreateInfo2>
{
enum
{
value = true
};
};
//=== VK_KHR_fragment_shading_rate ===
template <>
struct StructExtends<FragmentShadingRateAttachmentInfoKHR, SubpassDescription2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineFragmentShadingRateStateCreateInfoKHR, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentShadingRateFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentShadingRateFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentShadingRatePropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_AMD_shader_core_properties2 ===
template <>
struct StructExtends<PhysicalDeviceShaderCoreProperties2AMD, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_AMD_device_coherent_memory ===
template <>
struct StructExtends<PhysicalDeviceCoherentMemoryFeaturesAMD, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCoherentMemoryFeaturesAMD, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_dynamic_rendering_local_read ===
template <>
struct StructExtends<PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderingAttachmentLocationInfoKHR, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderingAttachmentLocationInfoKHR, CommandBufferInheritanceInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderingInputAttachmentIndexInfoKHR, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderingInputAttachmentIndexInfoKHR, CommandBufferInheritanceInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_shader_image_atomic_int64 ===
template <>
struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_shader_quad_control ===
template <>
struct StructExtends<PhysicalDeviceShaderQuadControlFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderQuadControlFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_memory_budget ===
template <>
struct StructExtends<PhysicalDeviceMemoryBudgetPropertiesEXT, PhysicalDeviceMemoryProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_memory_priority ===
template <>
struct StructExtends<PhysicalDeviceMemoryPriorityFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMemoryPriorityFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MemoryPriorityAllocateInfoEXT, MemoryAllocateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_surface_protected_capabilities ===
template <>
struct StructExtends<SurfaceProtectedCapabilitiesKHR, SurfaceCapabilities2KHR>
{
enum
{
value = true
};
};
//=== VK_NV_dedicated_allocation_image_aliasing ===
template <>
struct StructExtends<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_buffer_device_address ===
template <>
struct StructExtends<PhysicalDeviceBufferDeviceAddressFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceBufferDeviceAddressFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<BufferDeviceAddressCreateInfoEXT, BufferCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_validation_features ===
template <>
struct StructExtends<ValidationFeaturesEXT, InstanceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ValidationFeaturesEXT, ShaderModuleCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ValidationFeaturesEXT, ShaderCreateInfoEXT>
{
enum
{
value = true
};
};
//=== VK_KHR_present_wait ===
template <>
struct StructExtends<PhysicalDevicePresentWaitFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePresentWaitFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_cooperative_matrix ===
template <>
struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCooperativeMatrixPropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_NV_coverage_reduction_mode ===
template <>
struct StructExtends<PhysicalDeviceCoverageReductionModeFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCoverageReductionModeFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineCoverageReductionStateCreateInfoNV, PipelineMultisampleStateCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_fragment_shader_interlock ===
template <>
struct StructExtends<PhysicalDeviceFragmentShaderInterlockFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentShaderInterlockFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_ycbcr_image_arrays ===
template <>
struct StructExtends<PhysicalDeviceYcbcrImageArraysFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceYcbcrImageArraysFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_provoking_vertex ===
template <>
struct StructExtends<PhysicalDeviceProvokingVertexFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceProvokingVertexFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceProvokingVertexPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineRasterizationProvokingVertexStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>
{
enum
{
value = true
};
};
# if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_EXT_full_screen_exclusive ===
template <>
struct StructExtends<SurfaceFullScreenExclusiveInfoEXT, PhysicalDeviceSurfaceInfo2KHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SurfaceFullScreenExclusiveInfoEXT, SwapchainCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SurfaceCapabilitiesFullScreenExclusiveEXT, SurfaceCapabilities2KHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SurfaceFullScreenExclusiveWin32InfoEXT, PhysicalDeviceSurfaceInfo2KHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SurfaceFullScreenExclusiveWin32InfoEXT, SwapchainCreateInfoKHR>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_shader_atomic_float ===
template <>
struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_extended_dynamic_state ===
template <>
struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_pipeline_executable_properties ===
template <>
struct StructExtends<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_host_image_copy ===
template <>
struct StructExtends<PhysicalDeviceHostImageCopyFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceHostImageCopyFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceHostImageCopyPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SubresourceHostMemcpySizeEXT, SubresourceLayout2KHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<HostImageCopyDevicePerformanceQueryEXT, ImageFormatProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_map_memory_placed ===
template <>
struct StructExtends<PhysicalDeviceMapMemoryPlacedFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMapMemoryPlacedFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMapMemoryPlacedPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MemoryMapPlacedInfoEXT, MemoryMapInfoKHR>
{
enum
{
value = true
};
};
//=== VK_EXT_shader_atomic_float2 ===
template <>
struct StructExtends<PhysicalDeviceShaderAtomicFloat2FeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderAtomicFloat2FeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_surface_maintenance1 ===
template <>
struct StructExtends<SurfacePresentModeEXT, PhysicalDeviceSurfaceInfo2KHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SurfacePresentScalingCapabilitiesEXT, SurfaceCapabilities2KHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SurfacePresentModeCompatibilityEXT, SurfaceCapabilities2KHR>
{
enum
{
value = true
};
};
//=== VK_EXT_swapchain_maintenance1 ===
template <>
struct StructExtends<PhysicalDeviceSwapchainMaintenance1FeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSwapchainMaintenance1FeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SwapchainPresentFenceInfoEXT, PresentInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SwapchainPresentModesCreateInfoEXT, SwapchainCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SwapchainPresentModeInfoEXT, PresentInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SwapchainPresentScalingCreateInfoEXT, SwapchainCreateInfoKHR>
{
enum
{
value = true
};
};
//=== VK_NV_device_generated_commands ===
template <>
struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<GraphicsPipelineShaderGroupsCreateInfoNV, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_inherited_viewport_scissor ===
template <>
struct StructExtends<PhysicalDeviceInheritedViewportScissorFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceInheritedViewportScissorFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<CommandBufferInheritanceViewportScissorInfoNV, CommandBufferInheritanceInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_texel_buffer_alignment ===
template <>
struct StructExtends<PhysicalDeviceTexelBufferAlignmentFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceTexelBufferAlignmentFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_QCOM_render_pass_transform ===
template <>
struct StructExtends<RenderPassTransformBeginInfoQCOM, RenderPassBeginInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<CommandBufferInheritanceRenderPassTransformInfoQCOM, CommandBufferInheritanceInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_depth_bias_control ===
template <>
struct StructExtends<PhysicalDeviceDepthBiasControlFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDepthBiasControlFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DepthBiasRepresentationInfoEXT, DepthBiasInfoEXT>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DepthBiasRepresentationInfoEXT, PipelineRasterizationStateCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_device_memory_report ===
template <>
struct StructExtends<PhysicalDeviceDeviceMemoryReportFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDeviceMemoryReportFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DeviceDeviceMemoryReportCreateInfoEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_robustness2 ===
template <>
struct StructExtends<PhysicalDeviceRobustness2FeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRobustness2FeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRobustness2PropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_custom_border_color ===
template <>
struct StructExtends<SamplerCustomBorderColorCreateInfoEXT, SamplerCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCustomBorderColorPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCustomBorderColorFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCustomBorderColorFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_pipeline_library ===
template <>
struct StructExtends<PipelineLibraryCreateInfoKHR, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_present_barrier ===
template <>
struct StructExtends<PhysicalDevicePresentBarrierFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePresentBarrierFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SurfaceCapabilitiesPresentBarrierNV, SurfaceCapabilities2KHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SwapchainPresentBarrierCreateInfoNV, SwapchainCreateInfoKHR>
{
enum
{
value = true
};
};
//=== VK_KHR_present_id ===
template <>
struct StructExtends<PresentIdKHR, PresentInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePresentIdFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePresentIdFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_video_encode_queue ===
template <>
struct StructExtends<VideoEncodeCapabilitiesKHR, VideoCapabilitiesKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<QueryPoolVideoEncodeFeedbackCreateInfoKHR, QueryPoolCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeUsageInfoKHR, VideoProfileInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeUsageInfoKHR, QueryPoolCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeRateControlInfoKHR, VideoCodingControlInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeRateControlInfoKHR, VideoBeginCodingInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeQualityLevelInfoKHR, VideoCodingControlInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeQualityLevelInfoKHR, VideoSessionParametersCreateInfoKHR>
{
enum
{
value = true
};
};
//=== VK_NV_device_diagnostics_config ===
template <>
struct StructExtends<PhysicalDeviceDiagnosticsConfigFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDiagnosticsConfigFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DeviceDiagnosticsConfigCreateInfoNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
# if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_cuda_kernel_launch ===
template <>
struct StructExtends<PhysicalDeviceCudaKernelLaunchFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCudaKernelLaunchFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCudaKernelLaunchPropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_NV_low_latency ===
template <>
struct StructExtends<QueryLowLatencySupportNV, SemaphoreCreateInfo>
{
enum
{
value = true
};
};
# if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_objects ===
template <>
struct StructExtends<ExportMetalObjectCreateInfoEXT, InstanceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMetalObjectCreateInfoEXT, MemoryAllocateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMetalObjectCreateInfoEXT, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMetalObjectCreateInfoEXT, ImageViewCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMetalObjectCreateInfoEXT, BufferViewCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMetalObjectCreateInfoEXT, SemaphoreCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMetalObjectCreateInfoEXT, EventCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMetalDeviceInfoEXT, ExportMetalObjectsInfoEXT>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMetalCommandQueueInfoEXT, ExportMetalObjectsInfoEXT>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMetalBufferInfoEXT, ExportMetalObjectsInfoEXT>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImportMetalBufferInfoEXT, MemoryAllocateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMetalTextureInfoEXT, ExportMetalObjectsInfoEXT>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImportMetalTextureInfoEXT, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMetalIOSurfaceInfoEXT, ExportMetalObjectsInfoEXT>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImportMetalIOSurfaceInfoEXT, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExportMetalSharedEventInfoEXT, ExportMetalObjectsInfoEXT>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImportMetalSharedEventInfoEXT, SemaphoreCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImportMetalSharedEventInfoEXT, EventCreateInfo>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_synchronization2 ===
template <>
struct StructExtends<QueueFamilyCheckpointProperties2NV, QueueFamilyProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_descriptor_buffer ===
template <>
struct StructExtends<PhysicalDeviceDescriptorBufferPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDescriptorBufferFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDescriptorBufferFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DescriptorBufferBindingPushDescriptorBufferHandleEXT, DescriptorBufferBindingInfoEXT>
{
enum
{
value = true
};
};
template <>
struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, BufferCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, ImageViewCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, SamplerCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, AccelerationStructureCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, AccelerationStructureCreateInfoNV>
{
enum
{
value = true
};
};
//=== VK_EXT_graphics_pipeline_library ===
template <>
struct StructExtends<PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<GraphicsPipelineLibraryCreateInfoEXT, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
//=== VK_AMD_shader_early_and_late_fragment_tests ===
template <>
struct StructExtends<PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_fragment_shader_barycentric ===
template <>
struct StructExtends<PhysicalDeviceFragmentShaderBarycentricFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentShaderBarycentricFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentShaderBarycentricPropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_KHR_shader_subgroup_uniform_control_flow ===
template <>
struct StructExtends<PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_fragment_shading_rate_enums ===
template <>
struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsPropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineFragmentShadingRateEnumStateCreateInfoNV, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_ray_tracing_motion_blur ===
template <>
struct StructExtends<AccelerationStructureGeometryMotionTrianglesDataNV, AccelerationStructureGeometryTrianglesDataKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<AccelerationStructureMotionInfoNV, AccelerationStructureCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRayTracingMotionBlurFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRayTracingMotionBlurFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_mesh_shader ===
template <>
struct StructExtends<PhysicalDeviceMeshShaderFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMeshShaderFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMeshShaderPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_ycbcr_2plane_444_formats ===
template <>
struct StructExtends<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_fragment_density_map2 ===
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMap2FeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMap2FeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMap2PropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_QCOM_rotated_copy_commands ===
template <>
struct StructExtends<CopyCommandTransformInfoQCOM, BufferImageCopy2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<CopyCommandTransformInfoQCOM, ImageBlit2>
{
enum
{
value = true
};
};
//=== VK_KHR_workgroup_memory_explicit_layout ===
template <>
struct StructExtends<PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_image_compression_control ===
template <>
struct StructExtends<PhysicalDeviceImageCompressionControlFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageCompressionControlFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageCompressionControlEXT, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageCompressionControlEXT, SwapchainCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageCompressionControlEXT, PhysicalDeviceImageFormatInfo2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageCompressionPropertiesEXT, ImageFormatProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageCompressionPropertiesEXT, SurfaceFormat2KHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageCompressionPropertiesEXT, SubresourceLayout2KHR>
{
enum
{
value = true
};
};
//=== VK_EXT_attachment_feedback_loop_layout ===
template <>
struct StructExtends<PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_4444_formats ===
template <>
struct StructExtends<PhysicalDevice4444FormatsFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevice4444FormatsFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_device_fault ===
template <>
struct StructExtends<PhysicalDeviceFaultFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFaultFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_rgba10x6_formats ===
template <>
struct StructExtends<PhysicalDeviceRGBA10X6FormatsFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRGBA10X6FormatsFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_vertex_input_dynamic_state ===
template <>
struct StructExtends<PhysicalDeviceVertexInputDynamicStateFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVertexInputDynamicStateFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_physical_device_drm ===
template <>
struct StructExtends<PhysicalDeviceDrmPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_device_address_binding_report ===
template <>
struct StructExtends<PhysicalDeviceAddressBindingReportFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceAddressBindingReportFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DeviceAddressBindingCallbackDataEXT, DebugUtilsMessengerCallbackDataEXT>
{
enum
{
value = true
};
};
//=== VK_EXT_depth_clip_control ===
template <>
struct StructExtends<PhysicalDeviceDepthClipControlFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDepthClipControlFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineViewportDepthClipControlCreateInfoEXT, PipelineViewportStateCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_primitive_topology_list_restart ===
template <>
struct StructExtends<PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
# if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_external_memory ===
template <>
struct StructExtends<ImportMemoryZirconHandleInfoFUCHSIA, MemoryAllocateInfo>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_FUCHSIA*/
# if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_buffer_collection ===
template <>
struct StructExtends<ImportMemoryBufferCollectionFUCHSIA, MemoryAllocateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<BufferCollectionImageCreateInfoFUCHSIA, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<BufferCollectionBufferCreateInfoFUCHSIA, BufferCreateInfo>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_FUCHSIA*/
//=== VK_HUAWEI_subpass_shading ===
template <>
struct StructExtends<SubpassShadingPipelineCreateInfoHUAWEI, ComputePipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSubpassShadingFeaturesHUAWEI, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSubpassShadingFeaturesHUAWEI, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSubpassShadingPropertiesHUAWEI, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_HUAWEI_invocation_mask ===
template <>
struct StructExtends<PhysicalDeviceInvocationMaskFeaturesHUAWEI, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceInvocationMaskFeaturesHUAWEI, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_external_memory_rdma ===
template <>
struct StructExtends<PhysicalDeviceExternalMemoryRDMAFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceExternalMemoryRDMAFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_pipeline_properties ===
template <>
struct StructExtends<PhysicalDevicePipelinePropertiesFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePipelinePropertiesFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_frame_boundary ===
template <>
struct StructExtends<PhysicalDeviceFrameBoundaryFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFrameBoundaryFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<FrameBoundaryEXT, SubmitInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<FrameBoundaryEXT, SubmitInfo2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<FrameBoundaryEXT, PresentInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<FrameBoundaryEXT, BindSparseInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_multisampled_render_to_single_sampled ===
template <>
struct StructExtends<PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SubpassResolvePerformanceQueryEXT, FormatProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MultisampledRenderToSingleSampledInfoEXT, SubpassDescription2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MultisampledRenderToSingleSampledInfoEXT, RenderingInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_extended_dynamic_state2 ===
template <>
struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_color_write_enable ===
template <>
struct StructExtends<PhysicalDeviceColorWriteEnableFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceColorWriteEnableFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineColorWriteCreateInfoEXT, PipelineColorBlendStateCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_primitives_generated_query ===
template <>
struct StructExtends<PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_ray_tracing_maintenance1 ===
template <>
struct StructExtends<PhysicalDeviceRayTracingMaintenance1FeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRayTracingMaintenance1FeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_image_view_min_lod ===
template <>
struct StructExtends<PhysicalDeviceImageViewMinLodFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageViewMinLodFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageViewMinLodCreateInfoEXT, ImageViewCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_multi_draw ===
template <>
struct StructExtends<PhysicalDeviceMultiDrawFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMultiDrawFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMultiDrawPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_image_2d_view_of_3d ===
template <>
struct StructExtends<PhysicalDeviceImage2DViewOf3DFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImage2DViewOf3DFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_shader_tile_image ===
template <>
struct StructExtends<PhysicalDeviceShaderTileImageFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderTileImageFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderTileImagePropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_opacity_micromap ===
template <>
struct StructExtends<PhysicalDeviceOpacityMicromapFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceOpacityMicromapFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceOpacityMicromapPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<AccelerationStructureTrianglesOpacityMicromapEXT, AccelerationStructureGeometryTrianglesDataKHR>
{
enum
{
value = true
};
};
# if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_displacement_micromap ===
template <>
struct StructExtends<PhysicalDeviceDisplacementMicromapFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDisplacementMicromapFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDisplacementMicromapPropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<AccelerationStructureTrianglesDisplacementMicromapNV, AccelerationStructureGeometryTrianglesDataKHR>
{
enum
{
value = true
};
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_HUAWEI_cluster_culling_shader ===
template <>
struct StructExtends<PhysicalDeviceClusterCullingShaderFeaturesHUAWEI, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceClusterCullingShaderFeaturesHUAWEI, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceClusterCullingShaderPropertiesHUAWEI, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI, PhysicalDeviceClusterCullingShaderFeaturesHUAWEI>
{
enum
{
value = true
};
};
//=== VK_EXT_border_color_swizzle ===
template <>
struct StructExtends<PhysicalDeviceBorderColorSwizzleFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceBorderColorSwizzleFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SamplerBorderColorComponentMappingCreateInfoEXT, SamplerCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_pageable_device_local_memory ===
template <>
struct StructExtends<PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_ARM_shader_core_properties ===
template <>
struct StructExtends<PhysicalDeviceShaderCorePropertiesARM, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_KHR_shader_subgroup_rotate ===
template <>
struct StructExtends<PhysicalDeviceShaderSubgroupRotateFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderSubgroupRotateFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_ARM_scheduling_controls ===
template <>
struct StructExtends<DeviceQueueShaderCoreControlCreateInfoARM, DeviceQueueCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DeviceQueueShaderCoreControlCreateInfoARM, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSchedulingControlsFeaturesARM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSchedulingControlsFeaturesARM, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSchedulingControlsPropertiesARM, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_image_sliced_view_of_3d ===
template <>
struct StructExtends<PhysicalDeviceImageSlicedViewOf3DFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageSlicedViewOf3DFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageViewSlicedCreateInfoEXT, ImageViewCreateInfo>
{
enum
{
value = true
};
};
//=== VK_VALVE_descriptor_set_host_mapping ===
template <>
struct StructExtends<PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_depth_clamp_zero_one ===
template <>
struct StructExtends<PhysicalDeviceDepthClampZeroOneFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDepthClampZeroOneFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_non_seamless_cube_map ===
template <>
struct StructExtends<PhysicalDeviceNonSeamlessCubeMapFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceNonSeamlessCubeMapFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_ARM_render_pass_striped ===
template <>
struct StructExtends<PhysicalDeviceRenderPassStripedFeaturesARM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRenderPassStripedFeaturesARM, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRenderPassStripedPropertiesARM, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassStripeBeginInfoARM, RenderingInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassStripeBeginInfoARM, RenderPassBeginInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassStripeSubmitInfoARM, CommandBufferSubmitInfo>
{
enum
{
value = true
};
};
//=== VK_QCOM_fragment_density_map_offset ===
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SubpassFragmentDensityMapOffsetEndInfoQCOM, SubpassEndInfo>
{
enum
{
value = true
};
};
//=== VK_NV_copy_memory_indirect ===
template <>
struct StructExtends<PhysicalDeviceCopyMemoryIndirectFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCopyMemoryIndirectFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCopyMemoryIndirectPropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_NV_memory_decompression ===
template <>
struct StructExtends<PhysicalDeviceMemoryDecompressionFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMemoryDecompressionFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMemoryDecompressionPropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_NV_device_generated_commands_compute ===
template <>
struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ComputePipelineIndirectBufferInfoNV, ComputePipelineCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_linear_color_attachment ===
template <>
struct StructExtends<PhysicalDeviceLinearColorAttachmentFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceLinearColorAttachmentFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_shader_maximal_reconvergence ===
template <>
struct StructExtends<PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_image_compression_control_swapchain ===
template <>
struct StructExtends<PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_QCOM_image_processing ===
template <>
struct StructExtends<ImageViewSampleWeightCreateInfoQCOM, ImageViewCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageProcessingFeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageProcessingFeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageProcessingPropertiesQCOM, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_nested_command_buffer ===
template <>
struct StructExtends<PhysicalDeviceNestedCommandBufferFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceNestedCommandBufferFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceNestedCommandBufferPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_external_memory_acquire_unmodified ===
template <>
struct StructExtends<ExternalMemoryAcquireUnmodifiedEXT, BufferMemoryBarrier>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExternalMemoryAcquireUnmodifiedEXT, BufferMemoryBarrier2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExternalMemoryAcquireUnmodifiedEXT, ImageMemoryBarrier>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExternalMemoryAcquireUnmodifiedEXT, ImageMemoryBarrier2>
{
enum
{
value = true
};
};
//=== VK_EXT_extended_dynamic_state3 ===
template <>
struct StructExtends<PhysicalDeviceExtendedDynamicState3FeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceExtendedDynamicState3FeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceExtendedDynamicState3PropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_subpass_merge_feedback ===
template <>
struct StructExtends<PhysicalDeviceSubpassMergeFeedbackFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceSubpassMergeFeedbackFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassCreationControlEXT, RenderPassCreateInfo2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassCreationControlEXT, SubpassDescription2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassCreationFeedbackCreateInfoEXT, RenderPassCreateInfo2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassSubpassFeedbackCreateInfoEXT, SubpassDescription2>
{
enum
{
value = true
};
};
//=== VK_LUNARG_direct_driver_loading ===
template <>
struct StructExtends<DirectDriverLoadingListLUNARG, InstanceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_shader_module_identifier ===
template <>
struct StructExtends<PhysicalDeviceShaderModuleIdentifierFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderModuleIdentifierFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderModuleIdentifierPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineShaderStageModuleIdentifierCreateInfoEXT, PipelineShaderStageCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_rasterization_order_attachment_access ===
template <>
struct StructExtends<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_optical_flow ===
template <>
struct StructExtends<PhysicalDeviceOpticalFlowFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceOpticalFlowFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceOpticalFlowPropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<OpticalFlowImageFormatInfoNV, PhysicalDeviceImageFormatInfo2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<OpticalFlowImageFormatInfoNV, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<OpticalFlowSessionCreatePrivateDataInfoNV, OpticalFlowSessionCreateInfoNV>
{
enum
{
value = true
};
};
//=== VK_EXT_legacy_dithering ===
template <>
struct StructExtends<PhysicalDeviceLegacyDitheringFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceLegacyDitheringFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_pipeline_protected_access ===
template <>
struct StructExtends<PhysicalDevicePipelineProtectedAccessFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePipelineProtectedAccessFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
# if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_ANDROID_external_format_resolve ===
template <>
struct StructExtends<PhysicalDeviceExternalFormatResolveFeaturesANDROID, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceExternalFormatResolveFeaturesANDROID, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceExternalFormatResolvePropertiesANDROID, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<AndroidHardwareBufferFormatResolvePropertiesANDROID, AndroidHardwareBufferPropertiesANDROID>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
//=== VK_KHR_maintenance5 ===
template <>
struct StructExtends<PhysicalDeviceMaintenance5FeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance5FeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance5PropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineCreateFlags2CreateInfoKHR, ComputePipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineCreateFlags2CreateInfoKHR, GraphicsPipelineCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineCreateFlags2CreateInfoKHR, RayTracingPipelineCreateInfoNV>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineCreateFlags2CreateInfoKHR, RayTracingPipelineCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<BufferUsageFlags2CreateInfoKHR, BufferViewCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<BufferUsageFlags2CreateInfoKHR, BufferCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<BufferUsageFlags2CreateInfoKHR, PhysicalDeviceExternalBufferInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<BufferUsageFlags2CreateInfoKHR, DescriptorBufferBindingInfoEXT>
{
enum
{
value = true
};
};
//=== VK_AMD_anti_lag ===
template <>
struct StructExtends<PhysicalDeviceAntiLagFeaturesAMD, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceAntiLagFeaturesAMD, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_ray_tracing_position_fetch ===
template <>
struct StructExtends<PhysicalDeviceRayTracingPositionFetchFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRayTracingPositionFetchFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_shader_object ===
template <>
struct StructExtends<PhysicalDeviceShaderObjectFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderObjectFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderObjectPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_QCOM_tile_properties ===
template <>
struct StructExtends<PhysicalDeviceTilePropertiesFeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceTilePropertiesFeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_SEC_amigo_profiling ===
template <>
struct StructExtends<PhysicalDeviceAmigoProfilingFeaturesSEC, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceAmigoProfilingFeaturesSEC, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<AmigoProfilingSubmitInfoSEC, SubmitInfo>
{
enum
{
value = true
};
};
//=== VK_QCOM_multiview_per_view_viewports ===
template <>
struct StructExtends<PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_ray_tracing_invocation_reorder ===
template <>
struct StructExtends<PhysicalDeviceRayTracingInvocationReorderPropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRayTracingInvocationReorderFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRayTracingInvocationReorderFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_extended_sparse_address_space ===
template <>
struct StructExtends<PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceExtendedSparseAddressSpacePropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_mutable_descriptor_type ===
template <>
struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MutableDescriptorTypeCreateInfoEXT, DescriptorSetLayoutCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MutableDescriptorTypeCreateInfoEXT, DescriptorPoolCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_legacy_vertex_attributes ===
template <>
struct StructExtends<PhysicalDeviceLegacyVertexAttributesFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceLegacyVertexAttributesFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceLegacyVertexAttributesPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_layer_settings ===
template <>
struct StructExtends<LayerSettingsCreateInfoEXT, InstanceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_ARM_shader_core_builtins ===
template <>
struct StructExtends<PhysicalDeviceShaderCoreBuiltinsFeaturesARM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderCoreBuiltinsFeaturesARM, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderCoreBuiltinsPropertiesARM, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_pipeline_library_group_handles ===
template <>
struct StructExtends<PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_dynamic_rendering_unused_attachments ===
template <>
struct StructExtends<PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_low_latency2 ===
template <>
struct StructExtends<LatencySubmissionPresentIdNV, SubmitInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<LatencySubmissionPresentIdNV, SubmitInfo2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SwapchainLatencyCreateInfoNV, SwapchainCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<LatencySurfaceCapabilitiesNV, SurfaceCapabilities2KHR>
{
enum
{
value = true
};
};
//=== VK_KHR_cooperative_matrix ===
template <>
struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCooperativeMatrixPropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_QCOM_multiview_per_view_render_areas ===
template <>
struct StructExtends<PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM, RenderPassBeginInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM, RenderingInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_video_decode_av1 ===
template <>
struct StructExtends<VideoDecodeAV1ProfileInfoKHR, VideoProfileInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeAV1ProfileInfoKHR, QueryPoolCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeAV1CapabilitiesKHR, VideoCapabilitiesKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeAV1SessionParametersCreateInfoKHR, VideoSessionParametersCreateInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeAV1PictureInfoKHR, VideoDecodeInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoDecodeAV1DpbSlotInfoKHR, VideoReferenceSlotInfoKHR>
{
enum
{
value = true
};
};
//=== VK_KHR_video_maintenance1 ===
template <>
struct StructExtends<PhysicalDeviceVideoMaintenance1FeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVideoMaintenance1FeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoInlineQueryInfoKHR, VideoDecodeInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoInlineQueryInfoKHR, VideoEncodeInfoKHR>
{
enum
{
value = true
};
};
//=== VK_NV_per_stage_descriptor_set ===
template <>
struct StructExtends<PhysicalDevicePerStageDescriptorSetFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePerStageDescriptorSetFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_QCOM_image_processing2 ===
template <>
struct StructExtends<PhysicalDeviceImageProcessing2FeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageProcessing2FeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageProcessing2PropertiesQCOM, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SamplerBlockMatchWindowCreateInfoQCOM, SamplerCreateInfo>
{
enum
{
value = true
};
};
//=== VK_QCOM_filter_cubic_weights ===
template <>
struct StructExtends<PhysicalDeviceCubicWeightsFeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCubicWeightsFeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SamplerCubicWeightsCreateInfoQCOM, SamplerCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<BlitImageCubicWeightsInfoQCOM, BlitImageInfo2>
{
enum
{
value = true
};
};
//=== VK_QCOM_ycbcr_degamma ===
template <>
struct StructExtends<PhysicalDeviceYcbcrDegammaFeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceYcbcrDegammaFeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM, SamplerYcbcrConversionCreateInfo>
{
enum
{
value = true
};
};
//=== VK_QCOM_filter_cubic_clamp ===
template <>
struct StructExtends<PhysicalDeviceCubicClampFeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCubicClampFeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
template <>
struct StructExtends<PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_vertex_attribute_divisor ===
template <>
struct StructExtends<PhysicalDeviceVertexAttributeDivisorPropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineVertexInputDivisorStateCreateInfoKHR, PipelineVertexInputStateCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_shader_float_controls2 ===
template <>
struct StructExtends<PhysicalDeviceShaderFloatControls2FeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderFloatControls2FeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
# if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_external_memory_screen_buffer ===
template <>
struct StructExtends<ScreenBufferFormatPropertiesQNX, ScreenBufferPropertiesQNX>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImportScreenBufferInfoQNX, MemoryAllocateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExternalFormatQNX, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ExternalFormatQNX, SamplerYcbcrConversionCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX, DeviceCreateInfo>
{
enum
{
value = true
};
};
# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_MSFT_layered_driver ===
template <>
struct StructExtends<PhysicalDeviceLayeredDriverPropertiesMSFT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_KHR_index_type_uint8 ===
template <>
struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_line_rasterization ===
template <>
struct StructExtends<PhysicalDeviceLineRasterizationFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceLineRasterizationFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceLineRasterizationPropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PipelineRasterizationLineStateCreateInfoKHR, PipelineRasterizationStateCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_shader_expect_assume ===
template <>
struct StructExtends<PhysicalDeviceShaderExpectAssumeFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderExpectAssumeFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_maintenance6 ===
template <>
struct StructExtends<PhysicalDeviceMaintenance6FeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance6FeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance6PropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<BindMemoryStatusKHR, BindBufferMemoryInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<BindMemoryStatusKHR, BindImageMemoryInfo>
{
enum
{
value = true
};
};
//=== VK_NV_descriptor_pool_overallocation ===
template <>
struct StructExtends<PhysicalDeviceDescriptorPoolOverallocationFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDescriptorPoolOverallocationFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_raw_access_chains ===
template <>
struct StructExtends<PhysicalDeviceRawAccessChainsFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRawAccessChainsFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_shader_relaxed_extended_instruction ===
template <>
struct StructExtends<PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_command_buffer_inheritance ===
template <>
struct StructExtends<PhysicalDeviceCommandBufferInheritanceFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCommandBufferInheritanceFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_maintenance7 ===
template <>
struct StructExtends<PhysicalDeviceMaintenance7FeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance7FeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance7PropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceLayeredApiPropertiesListKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceLayeredApiVulkanPropertiesKHR, PhysicalDeviceLayeredApiPropertiesKHR>
{
enum
{
value = true
};
};
//=== VK_NV_shader_atomic_float16_vector ===
template <>
struct StructExtends<PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_shader_replicated_composites ===
template <>
struct StructExtends<PhysicalDeviceShaderReplicatedCompositesFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderReplicatedCompositesFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_ray_tracing_validation ===
template <>
struct StructExtends<PhysicalDeviceRayTracingValidationFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRayTracingValidationFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_MESA_image_alignment_control ===
template <>
struct StructExtends<PhysicalDeviceImageAlignmentControlFeaturesMESA, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageAlignmentControlFeaturesMESA, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageAlignmentControlPropertiesMESA, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageAlignmentControlCreateInfoMESA, ImageCreateInfo>
{
enum
{
value = true
};
};
#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
class DynamicLoader
{
public:
# ifdef VULKAN_HPP_NO_EXCEPTIONS
DynamicLoader( std::string const & vulkanLibraryName = {} ) VULKAN_HPP_NOEXCEPT
# else
DynamicLoader( std::string const & vulkanLibraryName = {} )
# endif
{
if ( !vulkanLibraryName.empty() )
{
# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
m_library = dlopen( vulkanLibraryName.c_str(), RTLD_NOW | RTLD_LOCAL );
# elif defined( _WIN32 )
m_library = ::LoadLibraryA( vulkanLibraryName.c_str() );
# else
# error unsupported platform
# endif
}
else
{
# if defined( __unix__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL );
if ( m_library == nullptr )
{
m_library = dlopen( "libvulkan.so.1", RTLD_NOW | RTLD_LOCAL );
}
# elif defined( __APPLE__ )
m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
if ( m_library == nullptr )
{
m_library = dlopen( "libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL );
}
# elif defined( _WIN32 )
m_library = ::LoadLibraryA( "vulkan-1.dll" );
# else
# error unsupported platform
# endif
}
# ifndef VULKAN_HPP_NO_EXCEPTIONS
if ( m_library == nullptr )
{
// NOTE there should be an InitializationFailedError, but msvc insists on the symbol does not exist within the scope of this function.
throw std::runtime_error( "Failed to load vulkan library!" );
}
# endif
}
DynamicLoader( DynamicLoader const & ) = delete;
DynamicLoader( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT : m_library( other.m_library )
{
other.m_library = nullptr;
}
DynamicLoader & operator=( DynamicLoader const & ) = delete;
DynamicLoader & operator=( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT
{
std::swap( m_library, other.m_library );
return *this;
}
~DynamicLoader() VULKAN_HPP_NOEXCEPT
{
if ( m_library )
{
# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
dlclose( m_library );
# elif defined( _WIN32 )
::FreeLibrary( m_library );
# else
# error unsupported platform
# endif
}
}
template <typename T>
T getProcAddress( const char * function ) const VULKAN_HPP_NOEXCEPT
{
# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
return (T)dlsym( m_library, function );
# elif defined( _WIN32 )
return ( T )::GetProcAddress( m_library, function );
# else
# error unsupported platform
# endif
}
bool success() const VULKAN_HPP_NOEXCEPT
{
return m_library != nullptr;
}
private:
# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
void * m_library;
# elif defined( _WIN32 )
::HINSTANCE m_library;
# else
# error unsupported platform
# endif
};
#endif
using PFN_dummy = void ( * )();
class DispatchLoaderDynamic : public DispatchLoaderBase
{
public:
//=== VK_VERSION_1_0 ===
PFN_vkCreateInstance vkCreateInstance = 0;
PFN_vkDestroyInstance vkDestroyInstance = 0;
PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0;
PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0;
PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0;
PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0;
PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0;
PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0;
PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0;
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0;
PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0;
PFN_vkCreateDevice vkCreateDevice = 0;
PFN_vkDestroyDevice vkDestroyDevice = 0;
PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0;
PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0;
PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0;
PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0;
PFN_vkGetDeviceQueue vkGetDeviceQueue = 0;
PFN_vkQueueSubmit vkQueueSubmit = 0;
PFN_vkQueueWaitIdle vkQueueWaitIdle = 0;
PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0;
PFN_vkAllocateMemory vkAllocateMemory = 0;
PFN_vkFreeMemory vkFreeMemory = 0;
PFN_vkMapMemory vkMapMemory = 0;
PFN_vkUnmapMemory vkUnmapMemory = 0;
PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0;
PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0;
PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0;
PFN_vkBindBufferMemory vkBindBufferMemory = 0;
PFN_vkBindImageMemory vkBindImageMemory = 0;
PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0;
PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0;
PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0;
PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0;
PFN_vkQueueBindSparse vkQueueBindSparse = 0;
PFN_vkCreateFence vkCreateFence = 0;
PFN_vkDestroyFence vkDestroyFence = 0;
PFN_vkResetFences vkResetFences = 0;
PFN_vkGetFenceStatus vkGetFenceStatus = 0;
PFN_vkWaitForFences vkWaitForFences = 0;
PFN_vkCreateSemaphore vkCreateSemaphore = 0;
PFN_vkDestroySemaphore vkDestroySemaphore = 0;
PFN_vkCreateEvent vkCreateEvent = 0;
PFN_vkDestroyEvent vkDestroyEvent = 0;
PFN_vkGetEventStatus vkGetEventStatus = 0;
PFN_vkSetEvent vkSetEvent = 0;
PFN_vkResetEvent vkResetEvent = 0;
PFN_vkCreateQueryPool vkCreateQueryPool = 0;
PFN_vkDestroyQueryPool vkDestroyQueryPool = 0;
PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0;
PFN_vkCreateBuffer vkCreateBuffer = 0;
PFN_vkDestroyBuffer vkDestroyBuffer = 0;
PFN_vkCreateBufferView vkCreateBufferView = 0;
PFN_vkDestroyBufferView vkDestroyBufferView = 0;
PFN_vkCreateImage vkCreateImage = 0;
PFN_vkDestroyImage vkDestroyImage = 0;
PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0;
PFN_vkCreateImageView vkCreateImageView = 0;
PFN_vkDestroyImageView vkDestroyImageView = 0;
PFN_vkCreateShaderModule vkCreateShaderModule = 0;
PFN_vkDestroyShaderModule vkDestroyShaderModule = 0;
PFN_vkCreatePipelineCache vkCreatePipelineCache = 0;
PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0;
PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0;
PFN_vkMergePipelineCaches vkMergePipelineCaches = 0;
PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0;
PFN_vkCreateComputePipelines vkCreateComputePipelines = 0;
PFN_vkDestroyPipeline vkDestroyPipeline = 0;
PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0;
PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0;
PFN_vkCreateSampler vkCreateSampler = 0;
PFN_vkDestroySampler vkDestroySampler = 0;
PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0;
PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0;
PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0;
PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0;
PFN_vkResetDescriptorPool vkResetDescriptorPool = 0;
PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0;
PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0;
PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0;
PFN_vkCreateFramebuffer vkCreateFramebuffer = 0;
PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0;
PFN_vkCreateRenderPass vkCreateRenderPass = 0;
PFN_vkDestroyRenderPass vkDestroyRenderPass = 0;
PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0;
PFN_vkCreateCommandPool vkCreateCommandPool = 0;
PFN_vkDestroyCommandPool vkDestroyCommandPool = 0;
PFN_vkResetCommandPool vkResetCommandPool = 0;
PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0;
PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0;
PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0;
PFN_vkEndCommandBuffer vkEndCommandBuffer = 0;
PFN_vkResetCommandBuffer vkResetCommandBuffer = 0;
PFN_vkCmdBindPipeline vkCmdBindPipeline = 0;
PFN_vkCmdSetViewport vkCmdSetViewport = 0;
PFN_vkCmdSetScissor vkCmdSetScissor = 0;
PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0;
PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0;
PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0;
PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0;
PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0;
PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0;
PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0;
PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0;
PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0;
PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0;
PFN_vkCmdDraw vkCmdDraw = 0;
PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0;
PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0;
PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0;
PFN_vkCmdDispatch vkCmdDispatch = 0;
PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0;
PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0;
PFN_vkCmdCopyImage vkCmdCopyImage = 0;
PFN_vkCmdBlitImage vkCmdBlitImage = 0;
PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0;
PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0;
PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0;
PFN_vkCmdFillBuffer vkCmdFillBuffer = 0;
PFN_vkCmdClearColorImage vkCmdClearColorImage = 0;
PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0;
PFN_vkCmdClearAttachments vkCmdClearAttachments = 0;
PFN_vkCmdResolveImage vkCmdResolveImage = 0;
PFN_vkCmdSetEvent vkCmdSetEvent = 0;
PFN_vkCmdResetEvent vkCmdResetEvent = 0;
PFN_vkCmdWaitEvents vkCmdWaitEvents = 0;
PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0;
PFN_vkCmdBeginQuery vkCmdBeginQuery = 0;
PFN_vkCmdEndQuery vkCmdEndQuery = 0;
PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0;
PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0;
PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0;
PFN_vkCmdPushConstants vkCmdPushConstants = 0;
PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0;
PFN_vkCmdNextSubpass vkCmdNextSubpass = 0;
PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0;
PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0;
//=== VK_VERSION_1_1 ===
PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0;
PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0;
PFN_vkBindImageMemory2 vkBindImageMemory2 = 0;
PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0;
PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0;
PFN_vkCmdDispatchBase vkCmdDispatchBase = 0;
PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0;
PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0;
PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0;
PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0;
PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0;
PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0;
PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0;
PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0;
PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0;
PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0;
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0;
PFN_vkTrimCommandPool vkTrimCommandPool = 0;
PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0;
PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0;
PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0;
PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0;
PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0;
PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0;
PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0;
PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0;
PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0;
PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0;
//=== VK_VERSION_1_2 ===
PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0;
PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0;
PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0;
PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = 0;
PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = 0;
PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = 0;
PFN_vkResetQueryPool vkResetQueryPool = 0;
PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = 0;
PFN_vkWaitSemaphores vkWaitSemaphores = 0;
PFN_vkSignalSemaphore vkSignalSemaphore = 0;
PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0;
PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = 0;
PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = 0;
//=== VK_VERSION_1_3 ===
PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties = 0;
PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot = 0;
PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot = 0;
PFN_vkSetPrivateData vkSetPrivateData = 0;
PFN_vkGetPrivateData vkGetPrivateData = 0;
PFN_vkCmdSetEvent2 vkCmdSetEvent2 = 0;
PFN_vkCmdResetEvent2 vkCmdResetEvent2 = 0;
PFN_vkCmdWaitEvents2 vkCmdWaitEvents2 = 0;
PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2 = 0;
PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2 = 0;
PFN_vkQueueSubmit2 vkQueueSubmit2 = 0;
PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2 = 0;
PFN_vkCmdCopyImage2 vkCmdCopyImage2 = 0;
PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2 = 0;
PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2 = 0;
PFN_vkCmdBlitImage2 vkCmdBlitImage2 = 0;
PFN_vkCmdResolveImage2 vkCmdResolveImage2 = 0;
PFN_vkCmdBeginRendering vkCmdBeginRendering = 0;
PFN_vkCmdEndRendering vkCmdEndRendering = 0;
PFN_vkCmdSetCullMode vkCmdSetCullMode = 0;
PFN_vkCmdSetFrontFace vkCmdSetFrontFace = 0;
PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology = 0;
PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount = 0;
PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount = 0;
PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2 = 0;
PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable = 0;
PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable = 0;
PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp = 0;
PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable = 0;
PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable = 0;
PFN_vkCmdSetStencilOp vkCmdSetStencilOp = 0;
PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable = 0;
PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable = 0;
PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable = 0;
PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements = 0;
PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements = 0;
PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements = 0;
//=== VK_KHR_surface ===
PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0;
PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0;
PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0;
PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0;
PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0;
//=== VK_KHR_swapchain ===
PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0;
PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0;
PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0;
PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0;
PFN_vkQueuePresentKHR vkQueuePresentKHR = 0;
PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0;
PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0;
PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0;
PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0;
//=== VK_KHR_display ===
PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0;
PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0;
PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0;
PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0;
PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0;
PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0;
PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0;
//=== VK_KHR_display_swapchain ===
PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0;
#if defined( VK_USE_PLATFORM_XLIB_KHR )
//=== VK_KHR_xlib_surface ===
PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0;
PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0;
#else
PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0;
PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
#if defined( VK_USE_PLATFORM_XCB_KHR )
//=== VK_KHR_xcb_surface ===
PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0;
PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0;
#else
PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0;
PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_XCB_KHR*/
#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
//=== VK_KHR_wayland_surface ===
PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0;
PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0;
#else
PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0;
PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_KHR_android_surface ===
PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0;
#else
PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_win32_surface ===
PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0;
PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0;
#else
PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0;
PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_debug_report ===
PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0;
PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0;
PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0;
//=== VK_EXT_debug_marker ===
PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0;
PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0;
PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0;
PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0;
PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0;
//=== VK_KHR_video_queue ===
PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR = 0;
PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR = 0;
PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR = 0;
PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR = 0;
PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR = 0;
PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR = 0;
PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR = 0;
PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR = 0;
PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR = 0;
PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR = 0;
PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR = 0;
PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR = 0;
//=== VK_KHR_video_decode_queue ===
PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR = 0;
//=== VK_EXT_transform_feedback ===
PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0;
PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0;
PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0;
PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0;
PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0;
PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0;
//=== VK_NVX_binary_import ===
PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX = 0;
PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX = 0;
PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX = 0;
PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX = 0;
PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0;
//=== VK_NVX_image_view_handle ===
PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0;
PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0;
//=== VK_AMD_draw_indirect_count ===
PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0;
PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0;
//=== VK_AMD_shader_info ===
PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0;
//=== VK_KHR_dynamic_rendering ===
PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR = 0;
PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR = 0;
#if defined( VK_USE_PLATFORM_GGP )
//=== VK_GGP_stream_descriptor_surface ===
PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0;
#else
PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0;
#endif /*VK_USE_PLATFORM_GGP*/
//=== VK_NV_external_memory_capabilities ===
PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_external_memory_win32 ===
PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0;
#else
PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_get_physical_device_properties2 ===
PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0;
PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0;
PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = 0;
PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = 0;
PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0;
PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0;
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0;
//=== VK_KHR_device_group ===
PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0;
PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0;
PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0;
#if defined( VK_USE_PLATFORM_VI_NN )
//=== VK_NN_vi_surface ===
PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0;
#else
PFN_dummy vkCreateViSurfaceNN_placeholder = 0;
#endif /*VK_USE_PLATFORM_VI_NN*/
//=== VK_KHR_maintenance1 ===
PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0;
//=== VK_KHR_device_group_creation ===
PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0;
//=== VK_KHR_external_memory_capabilities ===
PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_memory_win32 ===
PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0;
PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0;
#else
PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0;
PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_memory_fd ===
PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0;
PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0;
//=== VK_KHR_external_semaphore_capabilities ===
PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_semaphore_win32 ===
PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0;
PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0;
#else
PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0;
PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_semaphore_fd ===
PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0;
PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0;
//=== VK_KHR_push_descriptor ===
PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = 0;
PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0;
//=== VK_EXT_conditional_rendering ===
PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0;
PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0;
//=== VK_KHR_descriptor_update_template ===
PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0;
PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0;
PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0;
//=== VK_NV_clip_space_w_scaling ===
PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0;
//=== VK_EXT_direct_mode_display ===
PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0;
#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
//=== VK_EXT_acquire_xlib_display ===
PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0;
PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0;
#else
PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0;
PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0;
#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
//=== VK_EXT_display_surface_counter ===
PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0;
//=== VK_EXT_display_control ===
PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0;
PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0;
PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0;
PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0;
//=== VK_GOOGLE_display_timing ===
PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0;
PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0;
//=== VK_EXT_discard_rectangles ===
PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0;
PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT = 0;
PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT = 0;
//=== VK_EXT_hdr_metadata ===
PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0;
//=== VK_KHR_create_renderpass2 ===
PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0;
PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0;
PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 0;
PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0;
//=== VK_KHR_shared_presentable_image ===
PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0;
//=== VK_KHR_external_fence_capabilities ===
PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_fence_win32 ===
PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0;
PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0;
#else
PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0;
PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_fence_fd ===
PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0;
PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0;
//=== VK_KHR_performance_query ===
your_sha256_hashKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0;
PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0;
PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0;
PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0;
//=== VK_KHR_get_surface_capabilities2 ===
PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0;
PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0;
//=== VK_KHR_get_display_properties2 ===
PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0;
PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0;
PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0;
PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0;
#if defined( VK_USE_PLATFORM_IOS_MVK )
//=== VK_MVK_ios_surface ===
PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0;
#else
PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0;
#endif /*VK_USE_PLATFORM_IOS_MVK*/
#if defined( VK_USE_PLATFORM_MACOS_MVK )
//=== VK_MVK_macos_surface ===
PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0;
#else
PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0;
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
//=== VK_EXT_debug_utils ===
PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0;
PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0;
PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0;
PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0;
PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0;
PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0;
PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0;
PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0;
PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0;
PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0;
PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0;
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_ANDROID_external_memory_android_hardware_buffer ===
PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0;
PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0;
#else
PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0;
PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0;
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_shader_enqueue ===
PFN_vkCreateExecutionGraphPipelinesAMDX vkCreateExecutionGraphPipelinesAMDX = 0;
PFN_vkGetExecutionGraphPipelineScratchSizeAMDX vkGetExecutionGraphPipelineScratchSizeAMDX = 0;
PFN_vkGetExecutionGraphPipelineNodeIndexAMDX vkGetExecutionGraphPipelineNodeIndexAMDX = 0;
PFN_vkCmdInitializeGraphScratchMemoryAMDX vkCmdInitializeGraphScratchMemoryAMDX = 0;
PFN_vkCmdDispatchGraphAMDX vkCmdDispatchGraphAMDX = 0;
PFN_vkCmdDispatchGraphIndirectAMDX vkCmdDispatchGraphIndirectAMDX = 0;
PFN_vkCmdDispatchGraphIndirectCountAMDX vkCmdDispatchGraphIndirectCountAMDX = 0;
#else
PFN_dummy vkCreateExecutionGraphPipelinesAMDX_placeholder = 0;
PFN_dummy vkGetExecutionGraphPipelineScratchSizeAMDX_placeholder = 0;
PFN_dummy vkGetExecutionGraphPipelineNodeIndexAMDX_placeholder = 0;
PFN_dummy vkCmdInitializeGraphScratchMemoryAMDX_placeholder = 0;
PFN_dummy vkCmdDispatchGraphAMDX_placeholder = 0;
PFN_dummy vkCmdDispatchGraphIndirectAMDX_placeholder = 0;
PFN_dummy vkCmdDispatchGraphIndirectCountAMDX_placeholder = 0;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_sample_locations ===
PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0;
PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0;
//=== VK_KHR_get_memory_requirements2 ===
PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0;
PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0;
PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0;
//=== VK_KHR_acceleration_structure ===
PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR = 0;
PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = 0;
PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR = 0;
PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR = 0;
PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR = 0;
PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR = 0;
PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR = 0;
PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR = 0;
PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR = 0;
PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR = 0;
PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR = 0;
PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR = 0;
PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = 0;
PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR = 0;
PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0;
PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR = 0;
//=== VK_KHR_ray_tracing_pipeline ===
PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR = 0;
PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0;
PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = 0;
PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0;
PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR = 0;
PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR = 0;
PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR = 0;
//=== VK_KHR_sampler_ycbcr_conversion ===
PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0;
PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0;
//=== VK_KHR_bind_memory2 ===
PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0;
PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0;
//=== VK_EXT_image_drm_format_modifier ===
PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0;
//=== VK_EXT_validation_cache ===
PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0;
PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0;
PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0;
PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0;
//=== VK_NV_shading_rate_image ===
PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0;
PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0;
PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0;
//=== VK_NV_ray_tracing ===
PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0;
PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0;
PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0;
PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0;
PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0;
PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 0;
PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0;
PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0;
PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0;
PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0;
PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0;
PFN_vkCompileDeferredNV vkCompileDeferredNV = 0;
//=== VK_KHR_maintenance3 ===
PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0;
//=== VK_KHR_draw_indirect_count ===
PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0;
PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0;
//=== VK_EXT_external_memory_host ===
PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0;
//=== VK_AMD_buffer_marker ===
PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0;
//=== VK_EXT_calibrated_timestamps ===
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0;
PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0;
//=== VK_NV_mesh_shader ===
PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0;
PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0;
PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0;
//=== VK_NV_scissor_exclusive ===
PFN_vkCmdSetExclusiveScissorEnableNV vkCmdSetExclusiveScissorEnableNV = 0;
PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0;
//=== VK_NV_device_diagnostic_checkpoints ===
PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0;
PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 0;
//=== VK_KHR_timeline_semaphore ===
PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0;
PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0;
PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0;
//=== VK_INTEL_performance_query ===
PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0;
PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0;
PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0;
PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = 0;
PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0;
PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0;
PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0;
PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0;
PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0;
//=== VK_AMD_display_native_hdr ===
PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0;
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_imagepipe_surface ===
PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0;
#else
PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0;
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_surface ===
PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0;
#else
PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0;
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_fragment_shading_rate ===
PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0;
PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0;
//=== VK_KHR_dynamic_rendering_local_read ===
PFN_vkCmdSetRenderingAttachmentLocationsKHR vkCmdSetRenderingAttachmentLocationsKHR = 0;
PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR = 0;
//=== VK_EXT_buffer_device_address ===
PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0;
//=== VK_EXT_tooling_info ===
PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT = 0;
//=== VK_KHR_present_wait ===
PFN_vkWaitForPresentKHR vkWaitForPresentKHR = 0;
//=== VK_NV_cooperative_matrix ===
PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0;
//=== VK_NV_coverage_reduction_mode ===
your_sha256_hashonsNV your_sha256_hashV = 0;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_EXT_full_screen_exclusive ===
PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0;
PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0;
PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0;
PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0;
#else
PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0;
PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0;
PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0;
PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_headless_surface ===
PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0;
//=== VK_KHR_buffer_device_address ===
PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR = 0;
PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0;
PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0;
//=== VK_EXT_line_rasterization ===
PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0;
//=== VK_EXT_host_query_reset ===
PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0;
//=== VK_EXT_extended_dynamic_state ===
PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT = 0;
PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT = 0;
PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT = 0;
PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT = 0;
PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT = 0;
PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT = 0;
PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT = 0;
PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT = 0;
PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0;
PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0;
PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT = 0;
PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT = 0;
//=== VK_KHR_deferred_host_operations ===
PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0;
PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0;
PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0;
PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0;
PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR = 0;
//=== VK_KHR_pipeline_executable_properties ===
PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0;
PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0;
PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0;
//=== VK_EXT_host_image_copy ===
PFN_vkCopyMemoryToImageEXT vkCopyMemoryToImageEXT = 0;
PFN_vkCopyImageToMemoryEXT vkCopyImageToMemoryEXT = 0;
PFN_vkCopyImageToImageEXT vkCopyImageToImageEXT = 0;
PFN_vkTransitionImageLayoutEXT vkTransitionImageLayoutEXT = 0;
PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT = 0;
//=== VK_KHR_map_memory2 ===
PFN_vkMapMemory2KHR vkMapMemory2KHR = 0;
PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR = 0;
//=== VK_EXT_swapchain_maintenance1 ===
PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT = 0;
//=== VK_NV_device_generated_commands ===
PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0;
PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV = 0;
PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV = 0;
PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV = 0;
PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV = 0;
PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV = 0;
//=== VK_EXT_depth_bias_control ===
PFN_vkCmdSetDepthBias2EXT vkCmdSetDepthBias2EXT = 0;
//=== VK_EXT_acquire_drm_display ===
PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT = 0;
PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT = 0;
//=== VK_EXT_private_data ===
PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT = 0;
PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT = 0;
PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT = 0;
PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT = 0;
//=== VK_KHR_video_encode_queue ===
PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = 0;
PFN_vkGetEncodedVideoSessionParametersKHR vkGetEncodedVideoSessionParametersKHR = 0;
PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_cuda_kernel_launch ===
PFN_vkCreateCudaModuleNV vkCreateCudaModuleNV = 0;
PFN_vkGetCudaModuleCacheNV vkGetCudaModuleCacheNV = 0;
PFN_vkCreateCudaFunctionNV vkCreateCudaFunctionNV = 0;
PFN_vkDestroyCudaModuleNV vkDestroyCudaModuleNV = 0;
PFN_vkDestroyCudaFunctionNV vkDestroyCudaFunctionNV = 0;
PFN_vkCmdCudaLaunchKernelNV vkCmdCudaLaunchKernelNV = 0;
#else
PFN_dummy vkCreateCudaModuleNV_placeholder = 0;
PFN_dummy vkGetCudaModuleCacheNV_placeholder = 0;
PFN_dummy vkCreateCudaFunctionNV_placeholder = 0;
PFN_dummy vkDestroyCudaModuleNV_placeholder = 0;
PFN_dummy vkDestroyCudaFunctionNV_placeholder = 0;
PFN_dummy vkCmdCudaLaunchKernelNV_placeholder = 0;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_objects ===
PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0;
#else
PFN_dummy vkExportMetalObjectsEXT_placeholder = 0;
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_synchronization2 ===
PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR = 0;
PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR = 0;
PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR = 0;
PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0;
PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR = 0;
PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR = 0;
PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD = 0;
PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV = 0;
//=== VK_EXT_descriptor_buffer ===
PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT = 0;
PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT = 0;
PFN_vkGetDescriptorEXT vkGetDescriptorEXT = 0;
PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT = 0;
PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT = 0;
PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT = 0;
PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT = 0;
PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT = 0;
PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT = 0;
PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT = 0;
PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = 0;
//=== VK_NV_fragment_shading_rate_enums ===
PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0;
//=== VK_EXT_mesh_shader ===
PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT = 0;
PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT = 0;
PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT = 0;
//=== VK_KHR_copy_commands2 ===
PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR = 0;
PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR = 0;
PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR = 0;
PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0;
PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR = 0;
PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR = 0;
//=== VK_EXT_device_fault ===
PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT = 0;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_acquire_winrt_display ===
PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0;
PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0;
#else
PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0;
PFN_dummy vkGetWinrtDisplayNV_placeholder = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
//=== VK_EXT_directfb_surface ===
PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0;
PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0;
#else
PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0;
PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0;
#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
//=== VK_EXT_vertex_input_dynamic_state ===
PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0;
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_external_memory ===
PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0;
PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0;
#else
PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0;
PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0;
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_external_semaphore ===
PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0;
PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0;
#else
PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0;
PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0;
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_buffer_collection ===
PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA = 0;
PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA = 0;
PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA = 0;
PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0;
PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0;
#else
PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0;
PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0;
PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0;
PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0;
PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0;
#endif /*VK_USE_PLATFORM_FUCHSIA*/
//=== VK_HUAWEI_subpass_shading ===
PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 0;
PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI = 0;
//=== VK_HUAWEI_invocation_mask ===
PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI = 0;
//=== VK_NV_external_memory_rdma ===
PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV = 0;
//=== VK_EXT_pipeline_properties ===
PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT = 0;
//=== VK_EXT_extended_dynamic_state2 ===
PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT = 0;
PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0;
PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT = 0;
PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT = 0;
PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT = 0;
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_screen_surface ===
PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0;
PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0;
#else
PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0;
PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0;
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_EXT_color_write_enable ===
PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0;
//=== VK_KHR_ray_tracing_maintenance1 ===
PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR = 0;
//=== VK_EXT_multi_draw ===
PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT = 0;
PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT = 0;
//=== VK_EXT_opacity_micromap ===
PFN_vkCreateMicromapEXT vkCreateMicromapEXT = 0;
PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT = 0;
PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT = 0;
PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT = 0;
PFN_vkCopyMicromapEXT vkCopyMicromapEXT = 0;
PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT = 0;
PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT = 0;
PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT = 0;
PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT = 0;
PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT = 0;
PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT = 0;
PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT = 0;
PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT = 0;
PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT = 0;
//=== VK_HUAWEI_cluster_culling_shader ===
PFN_vkCmdDrawClusterHUAWEI vkCmdDrawClusterHUAWEI = 0;
PFN_vkCmdDrawClusterIndirectHUAWEI vkCmdDrawClusterIndirectHUAWEI = 0;
//=== VK_EXT_pageable_device_local_memory ===
PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT = 0;
//=== VK_KHR_maintenance4 ===
PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR = 0;
PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR = 0;
PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR = 0;
//=== VK_VALVE_descriptor_set_host_mapping ===
PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE = 0;
PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE = 0;
//=== VK_NV_copy_memory_indirect ===
PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV = 0;
PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV = 0;
//=== VK_NV_memory_decompression ===
PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV = 0;
PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV = 0;
//=== VK_NV_device_generated_commands_compute ===
PFN_vkGetPipelineIndirectMemoryRequirementsNV vkGetPipelineIndirectMemoryRequirementsNV = 0;
PFN_vkCmdUpdatePipelineIndirectBufferNV vkCmdUpdatePipelineIndirectBufferNV = 0;
PFN_vkGetPipelineIndirectDeviceAddressNV vkGetPipelineIndirectDeviceAddressNV = 0;
//=== VK_EXT_extended_dynamic_state3 ===
PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT = 0;
PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT = 0;
PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT = 0;
PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT = 0;
PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT = 0;
PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT = 0;
PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT = 0;
PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT = 0;
PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT = 0;
PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT = 0;
PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT = 0;
PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT = 0;
PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT = 0;
PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT = 0;
PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT = 0;
PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT = 0;
PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT = 0;
PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT = 0;
PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT = 0;
PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT = 0;
PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT = 0;
PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV = 0;
PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV = 0;
PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV = 0;
PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV = 0;
PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV = 0;
PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV = 0;
PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV = 0;
PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV = 0;
PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV = 0;
PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV = 0;
//=== VK_EXT_shader_module_identifier ===
PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT = 0;
PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT = 0;
//=== VK_NV_optical_flow ===
PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV = 0;
PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV = 0;
PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV = 0;
PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV = 0;
PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV = 0;
//=== VK_KHR_maintenance5 ===
PFN_vkCmdBindIndexBuffer2KHR vkCmdBindIndexBuffer2KHR = 0;
PFN_vkGetRenderingAreaGranularityKHR vkGetRenderingAreaGranularityKHR = 0;
PFN_vkGetDeviceImageSubresourceLayoutKHR vkGetDeviceImageSubresourceLayoutKHR = 0;
PFN_vkGetImageSubresourceLayout2KHR vkGetImageSubresourceLayout2KHR = 0;
//=== VK_AMD_anti_lag ===
PFN_vkAntiLagUpdateAMD vkAntiLagUpdateAMD = 0;
//=== VK_EXT_shader_object ===
PFN_vkCreateShadersEXT vkCreateShadersEXT = 0;
PFN_vkDestroyShaderEXT vkDestroyShaderEXT = 0;
PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT = 0;
PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT = 0;
//=== VK_QCOM_tile_properties ===
PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0;
PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0;
//=== VK_NV_low_latency2 ===
PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV = 0;
PFN_vkLatencySleepNV vkLatencySleepNV = 0;
PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV = 0;
PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV = 0;
PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV = 0;
//=== VK_KHR_cooperative_matrix ===
PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 0;
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT vkCmdSetAttachmentFeedbackLoopEnableEXT = 0;
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_external_memory_screen_buffer ===
PFN_vkGetScreenBufferPropertiesQNX vkGetScreenBufferPropertiesQNX = 0;
#else
PFN_dummy vkGetScreenBufferPropertiesQNX_placeholder = 0;
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_KHR_line_rasterization ===
PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR = 0;
//=== VK_KHR_calibrated_timestamps ===
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 0;
PFN_vkGetCalibratedTimestampsKHR vkGetCalibratedTimestampsKHR = 0;
//=== VK_KHR_maintenance6 ===
PFN_vkCmdBindDescriptorSets2KHR vkCmdBindDescriptorSets2KHR = 0;
PFN_vkCmdPushConstants2KHR vkCmdPushConstants2KHR = 0;
PFN_vkCmdPushDescriptorSet2KHR vkCmdPushDescriptorSet2KHR = 0;
PFN_vkCmdPushDescriptorSetWithTemplate2KHR vkCmdPushDescriptorSetWithTemplate2KHR = 0;
PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT = 0;
PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 0;
public:
DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT = default;
DispatchLoaderDynamic( DispatchLoaderDynamic const & rhs ) VULKAN_HPP_NOEXCEPT = default;
DispatchLoaderDynamic( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) VULKAN_HPP_NOEXCEPT
{
init( getInstanceProcAddr );
}
// This interface does not require a linked vulkan library.
DispatchLoaderDynamic( VkInstance instance,
PFN_vkGetInstanceProcAddr getInstanceProcAddr,
VkDevice device = {},
PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) VULKAN_HPP_NOEXCEPT
{
init( instance, getInstanceProcAddr, device, getDeviceProcAddr );
}
template <typename DynamicLoader
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
= VULKAN_HPP_NAMESPACE::DynamicLoader
#endif
>
void init()
{
static DynamicLoader dl;
init( dl );
}
template <typename DynamicLoader>
void init( DynamicLoader const & dl ) VULKAN_HPP_NOEXCEPT
{
PFN_vkGetInstanceProcAddr getInstanceProcAddr = dl.template getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" );
init( getInstanceProcAddr );
}
void init( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getInstanceProcAddr );
vkGetInstanceProcAddr = getInstanceProcAddr;
//=== VK_VERSION_1_0 ===
vkCreateInstance = PFN_vkCreateInstance( vkGetInstanceProcAddr( NULL, "vkCreateInstance" ) );
vkEnumerateInstanceExtensionProperties =
PFN_vkEnumerateInstanceExtensionProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceExtensionProperties" ) );
vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceLayerProperties" ) );
//=== VK_VERSION_1_1 ===
vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceVersion" ) );
}
// This interface does not require a linked vulkan library.
void init( VkInstance instance,
PFN_vkGetInstanceProcAddr getInstanceProcAddr,
VkDevice device = {},
PFN_vkGetDeviceProcAddr /*getDeviceProcAddr*/ = nullptr ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( instance && getInstanceProcAddr );
vkGetInstanceProcAddr = getInstanceProcAddr;
init( VULKAN_HPP_NAMESPACE::Instance( instance ) );
if ( device )
{
init( VULKAN_HPP_NAMESPACE::Device( device ) );
}
}
void init( VULKAN_HPP_NAMESPACE::Instance instanceCpp ) VULKAN_HPP_NOEXCEPT
{
VkInstance instance = static_cast<VkInstance>( instanceCpp );
//=== VK_VERSION_1_0 ===
vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) );
vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) );
vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) );
vkGetPhysicalDeviceFormatProperties = PFN_vkGetPhysicalDeviceFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) );
vkGetPhysicalDeviceImageFormatProperties =
PFN_vkGetPhysicalDeviceImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) );
vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) );
vkGetPhysicalDeviceQueueFamilyProperties =
PFN_vkGetPhysicalDeviceQueueFamilyProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) );
vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) );
vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) );
vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) );
vkDestroyDevice = PFN_vkDestroyDevice( vkGetInstanceProcAddr( instance, "vkDestroyDevice" ) );
vkEnumerateDeviceExtensionProperties =
PFN_vkEnumerateDeviceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) );
vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) );
vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue" ) );
vkQueueSubmit = PFN_vkQueueSubmit( vkGetInstanceProcAddr( instance, "vkQueueSubmit" ) );
vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) );
vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetInstanceProcAddr( instance, "vkDeviceWaitIdle" ) );
vkAllocateMemory = PFN_vkAllocateMemory( vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) );
vkFreeMemory = PFN_vkFreeMemory( vkGetInstanceProcAddr( instance, "vkFreeMemory" ) );
vkMapMemory = PFN_vkMapMemory( vkGetInstanceProcAddr( instance, "vkMapMemory" ) );
vkUnmapMemory = PFN_vkUnmapMemory( vkGetInstanceProcAddr( instance, "vkUnmapMemory" ) );
vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkFlushMappedMemoryRanges" ) );
vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkInvalidateMappedMemoryRanges" ) );
vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryCommitment" ) );
vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetInstanceProcAddr( instance, "vkBindBufferMemory" ) );
vkBindImageMemory = PFN_vkBindImageMemory( vkGetInstanceProcAddr( instance, "vkBindImageMemory" ) );
vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements" ) );
vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements" ) );
vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements" ) );
vkGetPhysicalDeviceSparseImageFormatProperties =
PFN_vkGetPhysicalDeviceSparseImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) );
vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetInstanceProcAddr( instance, "vkQueueBindSparse" ) );
vkCreateFence = PFN_vkCreateFence( vkGetInstanceProcAddr( instance, "vkCreateFence" ) );
vkDestroyFence = PFN_vkDestroyFence( vkGetInstanceProcAddr( instance, "vkDestroyFence" ) );
vkResetFences = PFN_vkResetFences( vkGetInstanceProcAddr( instance, "vkResetFences" ) );
vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetInstanceProcAddr( instance, "vkGetFenceStatus" ) );
vkWaitForFences = PFN_vkWaitForFences( vkGetInstanceProcAddr( instance, "vkWaitForFences" ) );
vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetInstanceProcAddr( instance, "vkCreateSemaphore" ) );
vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetInstanceProcAddr( instance, "vkDestroySemaphore" ) );
vkCreateEvent = PFN_vkCreateEvent( vkGetInstanceProcAddr( instance, "vkCreateEvent" ) );
vkDestroyEvent = PFN_vkDestroyEvent( vkGetInstanceProcAddr( instance, "vkDestroyEvent" ) );
vkGetEventStatus = PFN_vkGetEventStatus( vkGetInstanceProcAddr( instance, "vkGetEventStatus" ) );
vkSetEvent = PFN_vkSetEvent( vkGetInstanceProcAddr( instance, "vkSetEvent" ) );
vkResetEvent = PFN_vkResetEvent( vkGetInstanceProcAddr( instance, "vkResetEvent" ) );
vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetInstanceProcAddr( instance, "vkCreateQueryPool" ) );
vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetInstanceProcAddr( instance, "vkDestroyQueryPool" ) );
vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetInstanceProcAddr( instance, "vkGetQueryPoolResults" ) );
vkCreateBuffer = PFN_vkCreateBuffer( vkGetInstanceProcAddr( instance, "vkCreateBuffer" ) );
vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetInstanceProcAddr( instance, "vkDestroyBuffer" ) );
vkCreateBufferView = PFN_vkCreateBufferView( vkGetInstanceProcAddr( instance, "vkCreateBufferView" ) );
vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetInstanceProcAddr( instance, "vkDestroyBufferView" ) );
vkCreateImage = PFN_vkCreateImage( vkGetInstanceProcAddr( instance, "vkCreateImage" ) );
vkDestroyImage = PFN_vkDestroyImage( vkGetInstanceProcAddr( instance, "vkDestroyImage" ) );
vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout" ) );
vkCreateImageView = PFN_vkCreateImageView( vkGetInstanceProcAddr( instance, "vkCreateImageView" ) );
vkDestroyImageView = PFN_vkDestroyImageView( vkGetInstanceProcAddr( instance, "vkDestroyImageView" ) );
vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetInstanceProcAddr( instance, "vkCreateShaderModule" ) );
vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetInstanceProcAddr( instance, "vkDestroyShaderModule" ) );
vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetInstanceProcAddr( instance, "vkCreatePipelineCache" ) );
vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetInstanceProcAddr( instance, "vkDestroyPipelineCache" ) );
vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetInstanceProcAddr( instance, "vkGetPipelineCacheData" ) );
vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetInstanceProcAddr( instance, "vkMergePipelineCaches" ) );
vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetInstanceProcAddr( instance, "vkCreateGraphicsPipelines" ) );
vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetInstanceProcAddr( instance, "vkCreateComputePipelines" ) );
vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetInstanceProcAddr( instance, "vkDestroyPipeline" ) );
vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetInstanceProcAddr( instance, "vkCreatePipelineLayout" ) );
vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetInstanceProcAddr( instance, "vkDestroyPipelineLayout" ) );
vkCreateSampler = PFN_vkCreateSampler( vkGetInstanceProcAddr( instance, "vkCreateSampler" ) );
vkDestroySampler = PFN_vkDestroySampler( vkGetInstanceProcAddr( instance, "vkDestroySampler" ) );
vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkCreateDescriptorSetLayout" ) );
vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorSetLayout" ) );
vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetInstanceProcAddr( instance, "vkCreateDescriptorPool" ) );
vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorPool" ) );
vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) );
vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) );
vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetInstanceProcAddr( instance, "vkFreeDescriptorSets" ) );
vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSets" ) );
vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetInstanceProcAddr( instance, "vkCreateFramebuffer" ) );
vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetInstanceProcAddr( instance, "vkDestroyFramebuffer" ) );
vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetInstanceProcAddr( instance, "vkCreateRenderPass" ) );
vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetInstanceProcAddr( instance, "vkDestroyRenderPass" ) );
vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetInstanceProcAddr( instance, "vkGetRenderAreaGranularity" ) );
vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetInstanceProcAddr( instance, "vkCreateCommandPool" ) );
vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetInstanceProcAddr( instance, "vkDestroyCommandPool" ) );
vkResetCommandPool = PFN_vkResetCommandPool( vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) );
vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) );
vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetInstanceProcAddr( instance, "vkFreeCommandBuffers" ) );
vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetInstanceProcAddr( instance, "vkBeginCommandBuffer" ) );
vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetInstanceProcAddr( instance, "vkEndCommandBuffer" ) );
vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetInstanceProcAddr( instance, "vkResetCommandBuffer" ) );
vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetInstanceProcAddr( instance, "vkCmdBindPipeline" ) );
vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetInstanceProcAddr( instance, "vkCmdSetViewport" ) );
vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetInstanceProcAddr( instance, "vkCmdSetScissor" ) );
vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) );
vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias" ) );
vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetInstanceProcAddr( instance, "vkCmdSetBlendConstants" ) );
vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBounds" ) );
vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilCompareMask" ) );
vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilWriteMask" ) );
vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetInstanceProcAddr( instance, "vkCmdSetStencilReference" ) );
vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets" ) );
vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer" ) );
vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers" ) );
vkCmdDraw = PFN_vkCmdDraw( vkGetInstanceProcAddr( instance, "vkCmdDraw" ) );
vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexed" ) );
vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirect" ) );
vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirect" ) );
vkCmdDispatch = PFN_vkCmdDispatch( vkGetInstanceProcAddr( instance, "vkCmdDispatch" ) );
vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetInstanceProcAddr( instance, "vkCmdDispatchIndirect" ) );
vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer" ) );
vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetInstanceProcAddr( instance, "vkCmdCopyImage" ) );
vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetInstanceProcAddr( instance, "vkCmdBlitImage" ) );
vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage" ) );
vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer" ) );
vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetInstanceProcAddr( instance, "vkCmdUpdateBuffer" ) );
vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetInstanceProcAddr( instance, "vkCmdFillBuffer" ) );
vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetInstanceProcAddr( instance, "vkCmdClearColorImage" ) );
vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetInstanceProcAddr( instance, "vkCmdClearDepthStencilImage" ) );
vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetInstanceProcAddr( instance, "vkCmdClearAttachments" ) );
vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetInstanceProcAddr( instance, "vkCmdResolveImage" ) );
vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) );
vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetInstanceProcAddr( instance, "vkCmdResetEvent" ) );
vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents" ) );
vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier" ) );
vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetInstanceProcAddr( instance, "vkCmdBeginQuery" ) );
vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetInstanceProcAddr( instance, "vkCmdEndQuery" ) );
vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetInstanceProcAddr( instance, "vkCmdResetQueryPool" ) );
vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp" ) );
vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetInstanceProcAddr( instance, "vkCmdCopyQueryPoolResults" ) );
vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetInstanceProcAddr( instance, "vkCmdPushConstants" ) );
vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass" ) );
vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass" ) );
vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass" ) );
vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetInstanceProcAddr( instance, "vkCmdExecuteCommands" ) );
//=== VK_VERSION_1_1 ===
vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2" ) );
vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetInstanceProcAddr( instance, "vkBindImageMemory2" ) );
vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeatures" ) );
vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMask" ) );
vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetInstanceProcAddr( instance, "vkCmdDispatchBase" ) );
vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) );
vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2" ) );
vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2" ) );
vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2" ) );
vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) );
vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) );
vkGetPhysicalDeviceFormatProperties2 =
PFN_vkGetPhysicalDeviceFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) );
vkGetPhysicalDeviceImageFormatProperties2 =
PFN_vkGetPhysicalDeviceImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) );
vkGetPhysicalDeviceQueueFamilyProperties2 =
PFN_vkGetPhysicalDeviceQueueFamilyProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) );
vkGetPhysicalDeviceMemoryProperties2 =
PFN_vkGetPhysicalDeviceMemoryProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) );
vkGetPhysicalDeviceSparseImageFormatProperties2 =
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) );
vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetInstanceProcAddr( instance, "vkTrimCommandPool" ) );
vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue2" ) );
vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversion" ) );
vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversion" ) );
vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplate" ) );
vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplate" ) );
vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplate" ) );
vkGetPhysicalDeviceExternalBufferProperties =
PFN_vkGetPhysicalDeviceExternalBufferProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) );
vkGetPhysicalDeviceExternalFenceProperties =
PFN_vkGetPhysicalDeviceExternalFenceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) );
vkGetPhysicalDeviceExternalSemaphoreProperties =
PFN_vkGetPhysicalDeviceExternalSemaphoreProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) );
vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupport" ) );
//=== VK_VERSION_1_2 ===
vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCount" ) );
vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCount" ) );
vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2" ) );
vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2" ) );
vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2" ) );
vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2" ) );
vkResetQueryPool = PFN_vkResetQueryPool( vkGetInstanceProcAddr( instance, "vkResetQueryPool" ) );
vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValue" ) );
vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetInstanceProcAddr( instance, "vkWaitSemaphores" ) );
vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetInstanceProcAddr( instance, "vkSignalSemaphore" ) );
vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddress" ) );
vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddress" ) );
vkGetDeviceMemoryOpaqueCaptureAddress =
PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
//=== VK_VERSION_1_3 ===
vkGetPhysicalDeviceToolProperties = PFN_vkGetPhysicalDeviceToolProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolProperties" ) );
vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetInstanceProcAddr( instance, "vkCreatePrivateDataSlot" ) );
vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetInstanceProcAddr( instance, "vkDestroyPrivateDataSlot" ) );
vkSetPrivateData = PFN_vkSetPrivateData( vkGetInstanceProcAddr( instance, "vkSetPrivateData" ) );
vkGetPrivateData = PFN_vkGetPrivateData( vkGetInstanceProcAddr( instance, "vkGetPrivateData" ) );
vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetInstanceProcAddr( instance, "vkCmdSetEvent2" ) );
vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetInstanceProcAddr( instance, "vkCmdResetEvent2" ) );
vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents2" ) );
vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier2" ) );
vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp2" ) );
vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetInstanceProcAddr( instance, "vkQueueSubmit2" ) );
vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2" ) );
vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetInstanceProcAddr( instance, "vkCmdCopyImage2" ) );
vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage2" ) );
vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer2" ) );
vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetInstanceProcAddr( instance, "vkCmdBlitImage2" ) );
vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetInstanceProcAddr( instance, "vkCmdResolveImage2" ) );
vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetInstanceProcAddr( instance, "vkCmdBeginRendering" ) );
vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetInstanceProcAddr( instance, "vkCmdEndRendering" ) );
vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetInstanceProcAddr( instance, "vkCmdSetCullMode" ) );
vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFace" ) );
vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopology" ) );
vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCount" ) );
vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCount" ) );
vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2" ) );
vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnable" ) );
vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnable" ) );
vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOp" ) );
vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnable" ) );
vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnable" ) );
vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOp" ) );
vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnable" ) );
vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnable" ) );
vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnable" ) );
vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceBufferMemoryRequirements" ) );
vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceImageMemoryRequirements" ) );
vkGetDeviceImageSparseMemoryRequirements =
PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSparseMemoryRequirements" ) );
//=== VK_KHR_surface ===
vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) );
vkGetPhysicalDeviceSurfaceSupportKHR =
PFN_vkGetPhysicalDeviceSurfaceSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) );
vkGetPhysicalDeviceSurfaceCapabilitiesKHR =
PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) );
vkGetPhysicalDeviceSurfaceFormatsKHR =
PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) );
vkGetPhysicalDeviceSurfacePresentModesKHR =
PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) );
//=== VK_KHR_swapchain ===
vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetInstanceProcAddr( instance, "vkCreateSwapchainKHR" ) );
vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetInstanceProcAddr( instance, "vkDestroySwapchainKHR" ) );
vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainImagesKHR" ) );
vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) );
vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetInstanceProcAddr( instance, "vkQueuePresentKHR" ) );
vkGetDeviceGroupPresentCapabilitiesKHR =
PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
vkGetDeviceGroupSurfacePresentModesKHR =
PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
vkGetPhysicalDevicePresentRectanglesKHR =
PFN_vkGetPhysicalDevicePresentRectanglesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) );
vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) );
//=== VK_KHR_display ===
vkGetPhysicalDeviceDisplayPropertiesKHR =
PFN_vkGetPhysicalDeviceDisplayPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) );
vkGetPhysicalDeviceDisplayPlanePropertiesKHR =
PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" ) );
vkGetDisplayPlaneSupportedDisplaysKHR =
PFN_vkGetDisplayPlaneSupportedDisplaysKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) );
vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) );
vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) );
vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) );
vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) );
//=== VK_KHR_display_swapchain ===
vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetInstanceProcAddr( instance, "vkCreateSharedSwapchainsKHR" ) );
#if defined( VK_USE_PLATFORM_XLIB_KHR )
//=== VK_KHR_xlib_surface ===
vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ) );
vkGetPhysicalDeviceXlibPresentationSupportKHR =
PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ) );
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
#if defined( VK_USE_PLATFORM_XCB_KHR )
//=== VK_KHR_xcb_surface ===
vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ) );
vkGetPhysicalDeviceXcbPresentationSupportKHR =
PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ) );
#endif /*VK_USE_PLATFORM_XCB_KHR*/
#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
//=== VK_KHR_wayland_surface ===
vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ) );
vkGetPhysicalDeviceWaylandPresentationSupportKHR =
PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ) );
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_KHR_android_surface ===
vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) );
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_win32_surface ===
vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ) );
vkGetPhysicalDeviceWin32PresentationSupportKHR =
PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ) );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_debug_report ===
vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) );
vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugReportCallbackEXT" ) );
vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT( vkGetInstanceProcAddr( instance, "vkDebugReportMessageEXT" ) );
//=== VK_EXT_debug_marker ===
vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectTagEXT" ) );
vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectNameEXT" ) );
vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerBeginEXT" ) );
vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerEndEXT" ) );
vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerInsertEXT" ) );
//=== VK_KHR_video_queue ===
vkGetPhysicalDeviceVideoCapabilitiesKHR =
PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR" ) );
vkGetPhysicalDeviceVideoFormatPropertiesKHR =
PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR" ) );
vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetInstanceProcAddr( instance, "vkCreateVideoSessionKHR" ) );
vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionKHR" ) );
vkGetVideoSessionMemoryRequirementsKHR =
PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetVideoSessionMemoryRequirementsKHR" ) );
vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetInstanceProcAddr( instance, "vkBindVideoSessionMemoryKHR" ) );
vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkCreateVideoSessionParametersKHR" ) );
vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkUpdateVideoSessionParametersKHR" ) );
vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionParametersKHR" ) );
vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdBeginVideoCodingKHR" ) );
vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdEndVideoCodingKHR" ) );
vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdControlVideoCodingKHR" ) );
//=== VK_KHR_video_decode_queue ===
vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetInstanceProcAddr( instance, "vkCmdDecodeVideoKHR" ) );
//=== VK_EXT_transform_feedback ===
vkCmdBindTransformFeedbackBuffersEXT =
PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindTransformFeedbackBuffersEXT" ) );
vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginTransformFeedbackEXT" ) );
vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdEndTransformFeedbackEXT" ) );
vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginQueryIndexedEXT" ) );
vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdEndQueryIndexedEXT" ) );
vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectByteCountEXT" ) );
//=== VK_NVX_binary_import ===
vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetInstanceProcAddr( instance, "vkCreateCuModuleNVX" ) );
vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetInstanceProcAddr( instance, "vkCreateCuFunctionNVX" ) );
vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetInstanceProcAddr( instance, "vkDestroyCuModuleNVX" ) );
vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetInstanceProcAddr( instance, "vkDestroyCuFunctionNVX" ) );
vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetInstanceProcAddr( instance, "vkCmdCuLaunchKernelNVX" ) );
//=== VK_NVX_image_view_handle ===
vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewHandleNVX" ) );
vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewAddressNVX" ) );
//=== VK_AMD_draw_indirect_count ===
vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountAMD" ) );
if ( !vkCmdDrawIndirectCount )
vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD;
vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountAMD" ) );
if ( !vkCmdDrawIndexedIndirectCount )
vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD;
//=== VK_AMD_shader_info ===
vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetInstanceProcAddr( instance, "vkGetShaderInfoAMD" ) );
//=== VK_KHR_dynamic_rendering ===
vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderingKHR" ) );
if ( !vkCmdBeginRendering )
vkCmdBeginRendering = vkCmdBeginRenderingKHR;
vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderingKHR" ) );
if ( !vkCmdEndRendering )
vkCmdEndRendering = vkCmdEndRenderingKHR;
#if defined( VK_USE_PLATFORM_GGP )
//=== VK_GGP_stream_descriptor_surface ===
vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP( vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) );
#endif /*VK_USE_PLATFORM_GGP*/
//=== VK_NV_external_memory_capabilities ===
vkGetPhysicalDeviceExternalImageFormatPropertiesNV =
PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" ) );
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_external_memory_win32 ===
vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleNV" ) );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_get_physical_device_properties2 ===
vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2KHR" ) );
if ( !vkGetPhysicalDeviceFeatures2 )
vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2KHR;
vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) );
if ( !vkGetPhysicalDeviceProperties2 )
vkGetPhysicalDeviceProperties2 = vkGetPhysicalDeviceProperties2KHR;
vkGetPhysicalDeviceFormatProperties2KHR =
PFN_vkGetPhysicalDeviceFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2KHR" ) );
if ( !vkGetPhysicalDeviceFormatProperties2 )
vkGetPhysicalDeviceFormatProperties2 = vkGetPhysicalDeviceFormatProperties2KHR;
vkGetPhysicalDeviceImageFormatProperties2KHR =
PFN_vkGetPhysicalDeviceImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2KHR" ) );
if ( !vkGetPhysicalDeviceImageFormatProperties2 )
vkGetPhysicalDeviceImageFormatProperties2 = vkGetPhysicalDeviceImageFormatProperties2KHR;
vkGetPhysicalDeviceQueueFamilyProperties2KHR =
PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) );
if ( !vkGetPhysicalDeviceQueueFamilyProperties2 )
vkGetPhysicalDeviceQueueFamilyProperties2 = vkGetPhysicalDeviceQueueFamilyProperties2KHR;
vkGetPhysicalDeviceMemoryProperties2KHR =
PFN_vkGetPhysicalDeviceMemoryProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2KHR" ) );
if ( !vkGetPhysicalDeviceMemoryProperties2 )
vkGetPhysicalDeviceMemoryProperties2 = vkGetPhysicalDeviceMemoryProperties2KHR;
vkGetPhysicalDeviceSparseImageFormatProperties2KHR =
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) );
if ( !vkGetPhysicalDeviceSparseImageFormatProperties2 )
vkGetPhysicalDeviceSparseImageFormatProperties2 = vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
//=== VK_KHR_device_group ===
vkGetDeviceGroupPeerMemoryFeaturesKHR =
PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) );
if ( !vkGetDeviceGroupPeerMemoryFeatures )
vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR;
vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMaskKHR" ) );
if ( !vkCmdSetDeviceMask )
vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR;
vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetInstanceProcAddr( instance, "vkCmdDispatchBaseKHR" ) );
if ( !vkCmdDispatchBase )
vkCmdDispatchBase = vkCmdDispatchBaseKHR;
#if defined( VK_USE_PLATFORM_VI_NN )
//=== VK_NN_vi_surface ===
vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) );
#endif /*VK_USE_PLATFORM_VI_NN*/
//=== VK_KHR_maintenance1 ===
vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetInstanceProcAddr( instance, "vkTrimCommandPoolKHR" ) );
if ( !vkTrimCommandPool )
vkTrimCommandPool = vkTrimCommandPoolKHR;
//=== VK_KHR_device_group_creation ===
vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) );
if ( !vkEnumeratePhysicalDeviceGroups )
vkEnumeratePhysicalDeviceGroups = vkEnumeratePhysicalDeviceGroupsKHR;
//=== VK_KHR_external_memory_capabilities ===
vkGetPhysicalDeviceExternalBufferPropertiesKHR =
PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR" ) );
if ( !vkGetPhysicalDeviceExternalBufferProperties )
vkGetPhysicalDeviceExternalBufferProperties = vkGetPhysicalDeviceExternalBufferPropertiesKHR;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_memory_win32 ===
vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleKHR" ) );
vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandlePropertiesKHR" ) );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_memory_fd ===
vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdKHR" ) );
vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdPropertiesKHR" ) );
//=== VK_KHR_external_semaphore_capabilities ===
vkGetPhysicalDeviceExternalSemaphorePropertiesKHR =
PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" ) );
if ( !vkGetPhysicalDeviceExternalSemaphoreProperties )
vkGetPhysicalDeviceExternalSemaphoreProperties = vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_semaphore_win32 ===
vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreWin32HandleKHR" ) );
vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreWin32HandleKHR" ) );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_semaphore_fd ===
vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreFdKHR" ) );
vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreFdKHR" ) );
//=== VK_KHR_push_descriptor ===
vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetKHR" ) );
vkCmdPushDescriptorSetWithTemplateKHR =
PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplateKHR" ) );
//=== VK_EXT_conditional_rendering ===
vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginConditionalRenderingEXT" ) );
vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdEndConditionalRenderingEXT" ) );
//=== VK_KHR_descriptor_update_template ===
vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplateKHR" ) );
if ( !vkCreateDescriptorUpdateTemplate )
vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR;
vkDestroyDescriptorUpdateTemplateKHR =
PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplateKHR" ) );
if ( !vkDestroyDescriptorUpdateTemplate )
vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR;
vkUpdateDescriptorSetWithTemplateKHR =
PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplateKHR" ) );
if ( !vkUpdateDescriptorSetWithTemplate )
vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR;
//=== VK_NV_clip_space_w_scaling ===
vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingNV" ) );
//=== VK_EXT_direct_mode_display ===
vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) );
#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
//=== VK_EXT_acquire_xlib_display ===
vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) );
vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) );
#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
//=== VK_EXT_display_surface_counter ===
vkGetPhysicalDeviceSurfaceCapabilities2EXT =
PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) );
//=== VK_EXT_display_control ===
vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetInstanceProcAddr( instance, "vkDisplayPowerControlEXT" ) );
vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDeviceEventEXT" ) );
vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDisplayEventEXT" ) );
vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetInstanceProcAddr( instance, "vkGetSwapchainCounterEXT" ) );
//=== VK_GOOGLE_display_timing ===
vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetInstanceProcAddr( instance, "vkGetRefreshCycleDurationGOOGLE" ) );
vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingGOOGLE" ) );
//=== VK_EXT_discard_rectangles ===
vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) );
vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEnableEXT" ) );
vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleModeEXT" ) );
//=== VK_EXT_hdr_metadata ===
vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetInstanceProcAddr( instance, "vkSetHdrMetadataEXT" ) );
//=== VK_KHR_create_renderpass2 ===
vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2KHR" ) );
if ( !vkCreateRenderPass2 )
vkCreateRenderPass2 = vkCreateRenderPass2KHR;
vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2KHR" ) );
if ( !vkCmdBeginRenderPass2 )
vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR;
vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2KHR" ) );
if ( !vkCmdNextSubpass2 )
vkCmdNextSubpass2 = vkCmdNextSubpass2KHR;
vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2KHR" ) );
if ( !vkCmdEndRenderPass2 )
vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR;
//=== VK_KHR_shared_presentable_image ===
vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainStatusKHR" ) );
//=== VK_KHR_external_fence_capabilities ===
vkGetPhysicalDeviceExternalFencePropertiesKHR =
PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR" ) );
if ( !vkGetPhysicalDeviceExternalFenceProperties )
vkGetPhysicalDeviceExternalFenceProperties = vkGetPhysicalDeviceExternalFencePropertiesKHR;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_fence_win32 ===
vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportFenceWin32HandleKHR" ) );
vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetFenceWin32HandleKHR" ) );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_fence_fd ===
vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetInstanceProcAddr( instance, "vkImportFenceFdKHR" ) );
vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetInstanceProcAddr( instance, "vkGetFenceFdKHR" ) );
//=== VK_KHR_performance_query ===
vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = your_sha256_hashKHR(
vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) );
vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) );
vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkAcquireProfilingLockKHR" ) );
vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkReleaseProfilingLockKHR" ) );
//=== VK_KHR_get_surface_capabilities2 ===
vkGetPhysicalDeviceSurfaceCapabilities2KHR =
PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) );
vkGetPhysicalDeviceSurfaceFormats2KHR =
PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) );
//=== VK_KHR_get_display_properties2 ===
vkGetPhysicalDeviceDisplayProperties2KHR =
PFN_vkGetPhysicalDeviceDisplayProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) );
vkGetPhysicalDeviceDisplayPlaneProperties2KHR =
PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) );
vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) );
vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) );
#if defined( VK_USE_PLATFORM_IOS_MVK )
//=== VK_MVK_ios_surface ===
vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ) );
#endif /*VK_USE_PLATFORM_IOS_MVK*/
#if defined( VK_USE_PLATFORM_MACOS_MVK )
//=== VK_MVK_macos_surface ===
vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ) );
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
//=== VK_EXT_debug_utils ===
vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectNameEXT" ) );
vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectTagEXT" ) );
vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueBeginDebugUtilsLabelEXT" ) );
vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueEndDebugUtilsLabelEXT" ) );
vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueInsertDebugUtilsLabelEXT" ) );
vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginDebugUtilsLabelEXT" ) );
vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdEndDebugUtilsLabelEXT" ) );
vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdInsertDebugUtilsLabelEXT" ) );
vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) );
vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) );
vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) );
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_ANDROID_external_memory_android_hardware_buffer ===
vkGetAndroidHardwareBufferPropertiesANDROID =
PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetInstanceProcAddr( instance, "vkGetAndroidHardwareBufferPropertiesANDROID" ) );
vkGetMemoryAndroidHardwareBufferANDROID =
PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ) );
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_shader_enqueue ===
vkCreateExecutionGraphPipelinesAMDX = PFN_vkCreateExecutionGraphPipelinesAMDX( vkGetInstanceProcAddr( instance, "vkCreateExecutionGraphPipelinesAMDX" ) );
vkGetExecutionGraphPipelineScratchSizeAMDX =
PFN_vkGetExecutionGraphPipelineScratchSizeAMDX( vkGetInstanceProcAddr( instance, "vkGetExecutionGraphPipelineScratchSizeAMDX" ) );
vkGetExecutionGraphPipelineNodeIndexAMDX =
PFN_vkGetExecutionGraphPipelineNodeIndexAMDX( vkGetInstanceProcAddr( instance, "vkGetExecutionGraphPipelineNodeIndexAMDX" ) );
vkCmdInitializeGraphScratchMemoryAMDX =
PFN_vkCmdInitializeGraphScratchMemoryAMDX( vkGetInstanceProcAddr( instance, "vkCmdInitializeGraphScratchMemoryAMDX" ) );
vkCmdDispatchGraphAMDX = PFN_vkCmdDispatchGraphAMDX( vkGetInstanceProcAddr( instance, "vkCmdDispatchGraphAMDX" ) );
vkCmdDispatchGraphIndirectAMDX = PFN_vkCmdDispatchGraphIndirectAMDX( vkGetInstanceProcAddr( instance, "vkCmdDispatchGraphIndirectAMDX" ) );
vkCmdDispatchGraphIndirectCountAMDX = PFN_vkCmdDispatchGraphIndirectCountAMDX( vkGetInstanceProcAddr( instance, "vkCmdDispatchGraphIndirectCountAMDX" ) );
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_sample_locations ===
vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEXT" ) );
vkGetPhysicalDeviceMultisamplePropertiesEXT =
PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) );
//=== VK_KHR_get_memory_requirements2 ===
vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2KHR" ) );
if ( !vkGetImageMemoryRequirements2 )
vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR;
vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2KHR" ) );
if ( !vkGetBufferMemoryRequirements2 )
vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR;
vkGetImageSparseMemoryRequirements2KHR =
PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2KHR" ) );
if ( !vkGetImageSparseMemoryRequirements2 )
vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR;
//=== VK_KHR_acceleration_structure ===
vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureKHR" ) );
vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureKHR" ) );
vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructuresKHR" ) );
vkCmdBuildAccelerationStructuresIndirectKHR =
PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructuresIndirectKHR" ) );
vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetInstanceProcAddr( instance, "vkBuildAccelerationStructuresKHR" ) );
vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCopyAccelerationStructureKHR" ) );
vkCopyAccelerationStructureToMemoryKHR =
PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetInstanceProcAddr( instance, "vkCopyAccelerationStructureToMemoryKHR" ) );
vkCopyMemoryToAccelerationStructureKHR =
PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCopyMemoryToAccelerationStructureKHR" ) );
vkWriteAccelerationStructuresPropertiesKHR =
PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetInstanceProcAddr( instance, "vkWriteAccelerationStructuresPropertiesKHR" ) );
vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureKHR" ) );
vkCmdCopyAccelerationStructureToMemoryKHR =
PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureToMemoryKHR" ) );
vkCmdCopyMemoryToAccelerationStructureKHR =
PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToAccelerationStructureKHR" ) );
vkGetAccelerationStructureDeviceAddressKHR =
PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureDeviceAddressKHR" ) );
vkCmdWriteAccelerationStructuresPropertiesKHR =
PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) );
vkGetDeviceAccelerationStructureCompatibilityKHR =
PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) );
vkGetAccelerationStructureBuildSizesKHR =
PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureBuildSizesKHR" ) );
//=== VK_KHR_ray_tracing_pipeline ===
vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysKHR" ) );
vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesKHR" ) );
vkGetRayTracingShaderGroupHandlesKHR =
PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesKHR" ) );
vkGetRayTracingCaptureReplayShaderGroupHandlesKHR =
PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) );
vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysIndirectKHR" ) );
vkGetRayTracingShaderGroupStackSizeKHR =
PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupStackSizeKHR" ) );
vkCmdSetRayTracingPipelineStackSizeKHR =
PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRayTracingPipelineStackSizeKHR" ) );
//=== VK_KHR_sampler_ycbcr_conversion ===
vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversionKHR" ) );
if ( !vkCreateSamplerYcbcrConversion )
vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR;
vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversionKHR" ) );
if ( !vkDestroySamplerYcbcrConversion )
vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR;
//=== VK_KHR_bind_memory2 ===
vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2KHR" ) );
if ( !vkBindBufferMemory2 )
vkBindBufferMemory2 = vkBindBufferMemory2KHR;
vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindImageMemory2KHR" ) );
if ( !vkBindImageMemory2 )
vkBindImageMemory2 = vkBindImageMemory2KHR;
//=== VK_EXT_image_drm_format_modifier ===
vkGetImageDrmFormatModifierPropertiesEXT =
PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
//=== VK_EXT_validation_cache ===
vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkCreateValidationCacheEXT" ) );
vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkDestroyValidationCacheEXT" ) );
vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetInstanceProcAddr( instance, "vkMergeValidationCachesEXT" ) );
vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetInstanceProcAddr( instance, "vkGetValidationCacheDataEXT" ) );
//=== VK_NV_shading_rate_image ===
vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetInstanceProcAddr( instance, "vkCmdBindShadingRateImageNV" ) );
vkCmdSetViewportShadingRatePaletteNV =
PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportShadingRatePaletteNV" ) );
vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoarseSampleOrderNV" ) );
//=== VK_NV_ray_tracing ===
vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureNV" ) );
vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureNV" ) );
vkGetAccelerationStructureMemoryRequirementsNV =
PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureMemoryRequirementsNV" ) );
vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetInstanceProcAddr( instance, "vkBindAccelerationStructureMemoryNV" ) );
vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructureNV" ) );
vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureNV" ) );
vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysNV" ) );
vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesNV" ) );
vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesNV" ) );
if ( !vkGetRayTracingShaderGroupHandlesKHR )
vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV;
vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureHandleNV" ) );
vkCmdWriteAccelerationStructuresPropertiesNV =
PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetInstanceProcAddr( instance, "vkCompileDeferredNV" ) );
//=== VK_KHR_maintenance3 ===
vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupportKHR" ) );
if ( !vkGetDescriptorSetLayoutSupport )
vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR;
//=== VK_KHR_draw_indirect_count ===
vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountKHR" ) );
if ( !vkCmdDrawIndirectCount )
vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR;
vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountKHR" ) );
if ( !vkCmdDrawIndexedIndirectCount )
vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR;
//=== VK_EXT_external_memory_host ===
vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryHostPointerPropertiesEXT" ) );
//=== VK_AMD_buffer_marker ===
vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarkerAMD" ) );
//=== VK_EXT_calibrated_timestamps ===
vkGetPhysicalDeviceCalibrateableTimeDomainsEXT =
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) );
if ( !vkGetPhysicalDeviceCalibrateableTimeDomainsKHR )
vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = vkGetPhysicalDeviceCalibrateableTimeDomainsEXT;
vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsEXT" ) );
if ( !vkGetCalibratedTimestampsKHR )
vkGetCalibratedTimestampsKHR = vkGetCalibratedTimestampsEXT;
//=== VK_NV_mesh_shader ===
vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksNV" ) );
vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectNV" ) );
vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountNV" ) );
//=== VK_NV_scissor_exclusive ===
vkCmdSetExclusiveScissorEnableNV = PFN_vkCmdSetExclusiveScissorEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorEnableNV" ) );
vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) );
//=== VK_NV_device_diagnostic_checkpoints ===
vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetInstanceProcAddr( instance, "vkCmdSetCheckpointNV" ) );
vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointDataNV" ) );
//=== VK_KHR_timeline_semaphore ===
vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValueKHR" ) );
if ( !vkGetSemaphoreCounterValue )
vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR;
vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetInstanceProcAddr( instance, "vkWaitSemaphoresKHR" ) );
if ( !vkWaitSemaphores )
vkWaitSemaphores = vkWaitSemaphoresKHR;
vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetInstanceProcAddr( instance, "vkSignalSemaphoreKHR" ) );
if ( !vkSignalSemaphore )
vkSignalSemaphore = vkSignalSemaphoreKHR;
//=== VK_INTEL_performance_query ===
vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkInitializePerformanceApiINTEL" ) );
vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkUninitializePerformanceApiINTEL" ) );
vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceMarkerINTEL" ) );
vkCmdSetPerformanceStreamMarkerINTEL =
PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceOverrideINTEL" ) );
vkAcquirePerformanceConfigurationINTEL =
PFN_vkAcquirePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkAcquirePerformanceConfigurationINTEL" ) );
vkReleasePerformanceConfigurationINTEL =
PFN_vkReleasePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkReleasePerformanceConfigurationINTEL" ) );
vkQueueSetPerformanceConfigurationINTEL =
PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkQueueSetPerformanceConfigurationINTEL" ) );
vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetInstanceProcAddr( instance, "vkGetPerformanceParameterINTEL" ) );
//=== VK_AMD_display_native_hdr ===
vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetInstanceProcAddr( instance, "vkSetLocalDimmingAMD" ) );
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_imagepipe_surface ===
vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ) );
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_surface ===
vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) );
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_fragment_shading_rate ===
vkGetPhysicalDeviceFragmentShadingRatesKHR =
PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) );
vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateKHR" ) );
//=== VK_KHR_dynamic_rendering_local_read ===
vkCmdSetRenderingAttachmentLocationsKHR =
PFN_vkCmdSetRenderingAttachmentLocationsKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingAttachmentLocationsKHR" ) );
vkCmdSetRenderingInputAttachmentIndicesKHR =
PFN_vkCmdSetRenderingInputAttachmentIndicesKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingInputAttachmentIndicesKHR" ) );
//=== VK_EXT_buffer_device_address ===
vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressEXT" ) );
if ( !vkGetBufferDeviceAddress )
vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT;
//=== VK_EXT_tooling_info ===
vkGetPhysicalDeviceToolPropertiesEXT =
PFN_vkGetPhysicalDeviceToolPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolPropertiesEXT" ) );
if ( !vkGetPhysicalDeviceToolProperties )
vkGetPhysicalDeviceToolProperties = vkGetPhysicalDeviceToolPropertiesEXT;
//=== VK_KHR_present_wait ===
vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetInstanceProcAddr( instance, "vkWaitForPresentKHR" ) );
//=== VK_NV_cooperative_matrix ===
vkGetPhysicalDeviceCooperativeMatrixPropertiesNV =
PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV" ) );
//=== VK_NV_coverage_reduction_mode ===
your_sha256_hashV = your_sha256_hashonsNV(
vkGetInstanceProcAddr( instance, your_sha256_hashV" ) );
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_EXT_full_screen_exclusive ===
vkGetPhysicalDeviceSurfacePresentModes2EXT =
PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ) );
vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ) );
vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ) );
vkGetDeviceGroupSurfacePresentModes2EXT =
PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModes2EXT" ) );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_headless_surface ===
vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateHeadlessSurfaceEXT" ) );
//=== VK_KHR_buffer_device_address ===
vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressKHR" ) );
if ( !vkGetBufferDeviceAddress )
vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR;
vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddressKHR" ) );
if ( !vkGetBufferOpaqueCaptureAddress )
vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR;
vkGetDeviceMemoryOpaqueCaptureAddressKHR =
PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) );
if ( !vkGetDeviceMemoryOpaqueCaptureAddress )
vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR;
//=== VK_EXT_line_rasterization ===
vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEXT" ) );
if ( !vkCmdSetLineStippleKHR )
vkCmdSetLineStippleKHR = vkCmdSetLineStippleEXT;
//=== VK_EXT_host_query_reset ===
vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetInstanceProcAddr( instance, "vkResetQueryPoolEXT" ) );
if ( !vkResetQueryPool )
vkResetQueryPool = vkResetQueryPoolEXT;
//=== VK_EXT_extended_dynamic_state ===
vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetCullModeEXT" ) );
if ( !vkCmdSetCullMode )
vkCmdSetCullMode = vkCmdSetCullModeEXT;
vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFaceEXT" ) );
if ( !vkCmdSetFrontFace )
vkCmdSetFrontFace = vkCmdSetFrontFaceEXT;
vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopologyEXT" ) );
if ( !vkCmdSetPrimitiveTopology )
vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT;
vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCountEXT" ) );
if ( !vkCmdSetViewportWithCount )
vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT;
vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCountEXT" ) );
if ( !vkCmdSetScissorWithCount )
vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT;
vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2EXT" ) );
if ( !vkCmdBindVertexBuffers2 )
vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT;
vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnableEXT" ) );
if ( !vkCmdSetDepthTestEnable )
vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT;
vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnableEXT" ) );
if ( !vkCmdSetDepthWriteEnable )
vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT;
vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOpEXT" ) );
if ( !vkCmdSetDepthCompareOp )
vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT;
vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnableEXT" ) );
if ( !vkCmdSetDepthBoundsTestEnable )
vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT;
vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnableEXT" ) );
if ( !vkCmdSetStencilTestEnable )
vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT;
vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOpEXT" ) );
if ( !vkCmdSetStencilOp )
vkCmdSetStencilOp = vkCmdSetStencilOpEXT;
//=== VK_KHR_deferred_host_operations ===
vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetInstanceProcAddr( instance, "vkCreateDeferredOperationKHR" ) );
vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetInstanceProcAddr( instance, "vkDestroyDeferredOperationKHR" ) );
vkGetDeferredOperationMaxConcurrencyKHR =
PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetInstanceProcAddr( instance, "vkGetDeferredOperationMaxConcurrencyKHR" ) );
vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetInstanceProcAddr( instance, "vkGetDeferredOperationResultKHR" ) );
vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetInstanceProcAddr( instance, "vkDeferredOperationJoinKHR" ) );
//=== VK_KHR_pipeline_executable_properties ===
vkGetPipelineExecutablePropertiesKHR =
PFN_vkGetPipelineExecutablePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutablePropertiesKHR" ) );
vkGetPipelineExecutableStatisticsKHR =
PFN_vkGetPipelineExecutableStatisticsKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableStatisticsKHR" ) );
vkGetPipelineExecutableInternalRepresentationsKHR =
PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
//=== VK_EXT_host_image_copy ===
vkCopyMemoryToImageEXT = PFN_vkCopyMemoryToImageEXT( vkGetInstanceProcAddr( instance, "vkCopyMemoryToImageEXT" ) );
vkCopyImageToMemoryEXT = PFN_vkCopyImageToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCopyImageToMemoryEXT" ) );
vkCopyImageToImageEXT = PFN_vkCopyImageToImageEXT( vkGetInstanceProcAddr( instance, "vkCopyImageToImageEXT" ) );
vkTransitionImageLayoutEXT = PFN_vkTransitionImageLayoutEXT( vkGetInstanceProcAddr( instance, "vkTransitionImageLayoutEXT" ) );
vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout2EXT" ) );
if ( !vkGetImageSubresourceLayout2KHR )
vkGetImageSubresourceLayout2KHR = vkGetImageSubresourceLayout2EXT;
//=== VK_KHR_map_memory2 ===
vkMapMemory2KHR = PFN_vkMapMemory2KHR( vkGetInstanceProcAddr( instance, "vkMapMemory2KHR" ) );
vkUnmapMemory2KHR = PFN_vkUnmapMemory2KHR( vkGetInstanceProcAddr( instance, "vkUnmapMemory2KHR" ) );
//=== VK_EXT_swapchain_maintenance1 ===
vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetInstanceProcAddr( instance, "vkReleaseSwapchainImagesEXT" ) );
//=== VK_NV_device_generated_commands ===
vkGetGeneratedCommandsMemoryRequirementsNV =
PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetGeneratedCommandsMemoryRequirementsNV" ) );
vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetInstanceProcAddr( instance, "vkCmdPreprocessGeneratedCommandsNV" ) );
vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetInstanceProcAddr( instance, "vkCmdExecuteGeneratedCommandsNV" ) );
vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetInstanceProcAddr( instance, "vkCmdBindPipelineShaderGroupNV" ) );
vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetInstanceProcAddr( instance, "vkCreateIndirectCommandsLayoutNV" ) );
vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetInstanceProcAddr( instance, "vkDestroyIndirectCommandsLayoutNV" ) );
//=== VK_EXT_depth_bias_control ===
vkCmdSetDepthBias2EXT = PFN_vkCmdSetDepthBias2EXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias2EXT" ) );
//=== VK_EXT_acquire_drm_display ===
vkAcquireDrmDisplayEXT = PFN_vkAcquireDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireDrmDisplayEXT" ) );
vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetDrmDisplayEXT" ) );
//=== VK_EXT_private_data ===
vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetInstanceProcAddr( instance, "vkCreatePrivateDataSlotEXT" ) );
if ( !vkCreatePrivateDataSlot )
vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT;
vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetInstanceProcAddr( instance, "vkDestroyPrivateDataSlotEXT" ) );
if ( !vkDestroyPrivateDataSlot )
vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT;
vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkSetPrivateDataEXT" ) );
if ( !vkSetPrivateData )
vkSetPrivateData = vkSetPrivateDataEXT;
vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkGetPrivateDataEXT" ) );
if ( !vkGetPrivateData )
vkGetPrivateData = vkGetPrivateDataEXT;
//=== VK_KHR_video_encode_queue ===
vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(
vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR" ) );
vkGetEncodedVideoSessionParametersKHR =
PFN_vkGetEncodedVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkGetEncodedVideoSessionParametersKHR" ) );
vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetInstanceProcAddr( instance, "vkCmdEncodeVideoKHR" ) );
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_cuda_kernel_launch ===
vkCreateCudaModuleNV = PFN_vkCreateCudaModuleNV( vkGetInstanceProcAddr( instance, "vkCreateCudaModuleNV" ) );
vkGetCudaModuleCacheNV = PFN_vkGetCudaModuleCacheNV( vkGetInstanceProcAddr( instance, "vkGetCudaModuleCacheNV" ) );
vkCreateCudaFunctionNV = PFN_vkCreateCudaFunctionNV( vkGetInstanceProcAddr( instance, "vkCreateCudaFunctionNV" ) );
vkDestroyCudaModuleNV = PFN_vkDestroyCudaModuleNV( vkGetInstanceProcAddr( instance, "vkDestroyCudaModuleNV" ) );
vkDestroyCudaFunctionNV = PFN_vkDestroyCudaFunctionNV( vkGetInstanceProcAddr( instance, "vkDestroyCudaFunctionNV" ) );
vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetInstanceProcAddr( instance, "vkCmdCudaLaunchKernelNV" ) );
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_objects ===
vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetInstanceProcAddr( instance, "vkExportMetalObjectsEXT" ) );
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_synchronization2 ===
vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdSetEvent2KHR" ) );
if ( !vkCmdSetEvent2 )
vkCmdSetEvent2 = vkCmdSetEvent2KHR;
vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdResetEvent2KHR" ) );
if ( !vkCmdResetEvent2 )
vkCmdResetEvent2 = vkCmdResetEvent2KHR;
vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents2KHR" ) );
if ( !vkCmdWaitEvents2 )
vkCmdWaitEvents2 = vkCmdWaitEvents2KHR;
vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier2KHR" ) );
if ( !vkCmdPipelineBarrier2 )
vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR;
vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp2KHR" ) );
if ( !vkCmdWriteTimestamp2 )
vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR;
vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetInstanceProcAddr( instance, "vkQueueSubmit2KHR" ) );
if ( !vkQueueSubmit2 )
vkQueueSubmit2 = vkQueueSubmit2KHR;
vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarker2AMD" ) );
vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointData2NV" ) );
//=== VK_EXT_descriptor_buffer ===
vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSizeEXT" ) );
vkGetDescriptorSetLayoutBindingOffsetEXT =
PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) );
vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorEXT" ) );
vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBuffersEXT" ) );
vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDescriptorBufferOffsetsEXT" ) );
vkCmdBindDescriptorBufferEmbeddedSamplersEXT =
PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) );
vkGetBufferOpaqueCaptureDescriptorDataEXT =
PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) );
vkGetImageOpaqueCaptureDescriptorDataEXT =
PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) );
vkGetImageViewOpaqueCaptureDescriptorDataEXT =
PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) );
vkGetSamplerOpaqueCaptureDescriptorDataEXT =
PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) );
vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) );
//=== VK_NV_fragment_shading_rate_enums ===
vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateEnumNV" ) );
//=== VK_EXT_mesh_shader ===
vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksEXT" ) );
vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectEXT" ) );
vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountEXT" ) );
//=== VK_KHR_copy_commands2 ===
vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2KHR" ) );
if ( !vkCmdCopyBuffer2 )
vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR;
vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImage2KHR" ) );
if ( !vkCmdCopyImage2 )
vkCmdCopyImage2 = vkCmdCopyImage2KHR;
vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage2KHR" ) );
if ( !vkCmdCopyBufferToImage2 )
vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR;
vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer2KHR" ) );
if ( !vkCmdCopyImageToBuffer2 )
vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR;
vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdBlitImage2KHR" ) );
if ( !vkCmdBlitImage2 )
vkCmdBlitImage2 = vkCmdBlitImage2KHR;
vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdResolveImage2KHR" ) );
if ( !vkCmdResolveImage2 )
vkCmdResolveImage2 = vkCmdResolveImage2KHR;
//=== VK_EXT_device_fault ===
vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetInstanceProcAddr( instance, "vkGetDeviceFaultInfoEXT" ) );
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_acquire_winrt_display ===
vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) );
vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
//=== VK_EXT_directfb_surface ===
vkCreateDirectFBSurfaceEXT = PFN_vkCreateDirectFBSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ) );
vkGetPhysicalDeviceDirectFBPresentationSupportEXT =
PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ) );
#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
//=== VK_EXT_vertex_input_dynamic_state ===
vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetInstanceProcAddr( instance, "vkCmdSetVertexInputEXT" ) );
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_external_memory ===
vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandleFUCHSIA" ) );
vkGetMemoryZirconHandlePropertiesFUCHSIA =
PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) );
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_external_semaphore ===
vkImportSemaphoreZirconHandleFUCHSIA =
PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkImportSemaphoreZirconHandleFUCHSIA" ) );
vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetSemaphoreZirconHandleFUCHSIA" ) );
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_buffer_collection ===
vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateBufferCollectionFUCHSIA" ) );
vkSetBufferCollectionImageConstraintsFUCHSIA =
PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetInstanceProcAddr( instance, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) );
vkSetBufferCollectionBufferConstraintsFUCHSIA =
PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetInstanceProcAddr( instance, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) );
vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetInstanceProcAddr( instance, "vkDestroyBufferCollectionFUCHSIA" ) );
vkGetBufferCollectionPropertiesFUCHSIA =
PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetBufferCollectionPropertiesFUCHSIA" ) );
#endif /*VK_USE_PLATFORM_FUCHSIA*/
//=== VK_HUAWEI_subpass_shading ===
vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI =
PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetInstanceProcAddr( instance, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) );
vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdSubpassShadingHUAWEI" ) );
//=== VK_HUAWEI_invocation_mask ===
vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdBindInvocationMaskHUAWEI" ) );
//=== VK_NV_external_memory_rdma ===
vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetInstanceProcAddr( instance, "vkGetMemoryRemoteAddressNV" ) );
//=== VK_EXT_pipeline_properties ===
vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPipelinePropertiesEXT" ) );
//=== VK_EXT_extended_dynamic_state2 ===
vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPatchControlPointsEXT" ) );
vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnableEXT" ) );
if ( !vkCmdSetRasterizerDiscardEnable )
vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT;
vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnableEXT" ) );
if ( !vkCmdSetDepthBiasEnable )
vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT;
vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEXT" ) );
vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnableEXT" ) );
if ( !vkCmdSetPrimitiveRestartEnable )
vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT;
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_screen_surface ===
vkCreateScreenSurfaceQNX = PFN_vkCreateScreenSurfaceQNX( vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ) );
vkGetPhysicalDeviceScreenPresentationSupportQNX =
PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ) );
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_EXT_color_write_enable ===
vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteEnableEXT" ) );
//=== VK_KHR_ray_tracing_maintenance1 ===
vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysIndirect2KHR" ) );
//=== VK_EXT_multi_draw ===
vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMultiEXT" ) );
vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMultiIndexedEXT" ) );
//=== VK_EXT_opacity_micromap ===
vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetInstanceProcAddr( instance, "vkCreateMicromapEXT" ) );
vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetInstanceProcAddr( instance, "vkDestroyMicromapEXT" ) );
vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetInstanceProcAddr( instance, "vkCmdBuildMicromapsEXT" ) );
vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetInstanceProcAddr( instance, "vkBuildMicromapsEXT" ) );
vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetInstanceProcAddr( instance, "vkCopyMicromapEXT" ) );
vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCopyMicromapToMemoryEXT" ) );
vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetInstanceProcAddr( instance, "vkCopyMemoryToMicromapEXT" ) );
vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetInstanceProcAddr( instance, "vkWriteMicromapsPropertiesEXT" ) );
vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMicromapEXT" ) );
vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMicromapToMemoryEXT" ) );
vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToMicromapEXT" ) );
vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetInstanceProcAddr( instance, "vkCmdWriteMicromapsPropertiesEXT" ) );
vkGetDeviceMicromapCompatibilityEXT = PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetInstanceProcAddr( instance, "vkGetDeviceMicromapCompatibilityEXT" ) );
vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetInstanceProcAddr( instance, "vkGetMicromapBuildSizesEXT" ) );
//=== VK_HUAWEI_cluster_culling_shader ===
vkCmdDrawClusterHUAWEI = PFN_vkCmdDrawClusterHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdDrawClusterHUAWEI" ) );
vkCmdDrawClusterIndirectHUAWEI = PFN_vkCmdDrawClusterIndirectHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdDrawClusterIndirectHUAWEI" ) );
//=== VK_EXT_pageable_device_local_memory ===
vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetInstanceProcAddr( instance, "vkSetDeviceMemoryPriorityEXT" ) );
//=== VK_KHR_maintenance4 ===
vkGetDeviceBufferMemoryRequirementsKHR =
PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceBufferMemoryRequirementsKHR" ) );
if ( !vkGetDeviceBufferMemoryRequirements )
vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR;
vkGetDeviceImageMemoryRequirementsKHR =
PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageMemoryRequirementsKHR" ) );
if ( !vkGetDeviceImageMemoryRequirements )
vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR;
vkGetDeviceImageSparseMemoryRequirementsKHR =
PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) );
if ( !vkGetDeviceImageSparseMemoryRequirements )
vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR;
//=== VK_VALVE_descriptor_set_host_mapping ===
vkGetDescriptorSetLayoutHostMappingInfoVALVE =
PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) );
vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetHostMappingVALVE" ) );
//=== VK_NV_copy_memory_indirect ===
vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryIndirectNV" ) );
vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToImageIndirectNV" ) );
//=== VK_NV_memory_decompression ===
vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryNV" ) );
vkCmdDecompressMemoryIndirectCountNV =
PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryIndirectCountNV" ) );
//=== VK_NV_device_generated_commands_compute ===
vkGetPipelineIndirectMemoryRequirementsNV =
PFN_vkGetPipelineIndirectMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetPipelineIndirectMemoryRequirementsNV" ) );
vkCmdUpdatePipelineIndirectBufferNV = PFN_vkCmdUpdatePipelineIndirectBufferNV( vkGetInstanceProcAddr( instance, "vkCmdUpdatePipelineIndirectBufferNV" ) );
vkGetPipelineIndirectDeviceAddressNV =
PFN_vkGetPipelineIndirectDeviceAddressNV( vkGetInstanceProcAddr( instance, "vkGetPipelineIndirectDeviceAddressNV" ) );
//=== VK_EXT_extended_dynamic_state3 ===
vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClampEnableEXT" ) );
vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPolygonModeEXT" ) );
vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizationSamplesEXT" ) );
vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleMaskEXT" ) );
vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAlphaToCoverageEnableEXT" ) );
vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAlphaToOneEnableEXT" ) );
vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEnableEXT" ) );
vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendEnableEXT" ) );
vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendEquationEXT" ) );
vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteMaskEXT" ) );
vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetInstanceProcAddr( instance, "vkCmdSetTessellationDomainOriginEXT" ) );
vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizationStreamEXT" ) );
vkCmdSetConservativeRasterizationModeEXT =
PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetConservativeRasterizationModeEXT" ) );
vkCmdSetExtraPrimitiveOverestimationSizeEXT =
PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) );
vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClipEnableEXT" ) );
vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEnableEXT" ) );
vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendAdvancedEXT" ) );
vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetProvokingVertexModeEXT" ) );
vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineRasterizationModeEXT" ) );
vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEnableEXT" ) );
vkCmdSetDepthClipNegativeOneToOneEXT =
PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClipNegativeOneToOneEXT" ) );
vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingEnableNV" ) );
vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportSwizzleNV" ) );
vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageToColorEnableNV" ) );
vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageToColorLocationNV" ) );
vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationModeNV" ) );
vkCmdSetCoverageModulationTableEnableNV =
PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationTableEnableNV" ) );
vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationTableNV" ) );
vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetShadingRateImageEnableNV" ) );
vkCmdSetRepresentativeFragmentTestEnableNV =
PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetRepresentativeFragmentTestEnableNV" ) );
vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageReductionModeNV" ) );
//=== VK_EXT_shader_module_identifier ===
vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetInstanceProcAddr( instance, "vkGetShaderModuleIdentifierEXT" ) );
vkGetShaderModuleCreateInfoIdentifierEXT =
PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetInstanceProcAddr( instance, "vkGetShaderModuleCreateInfoIdentifierEXT" ) );
//=== VK_NV_optical_flow ===
vkGetPhysicalDeviceOpticalFlowImageFormatsNV =
PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV" ) );
vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetInstanceProcAddr( instance, "vkCreateOpticalFlowSessionNV" ) );
vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetInstanceProcAddr( instance, "vkDestroyOpticalFlowSessionNV" ) );
vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetInstanceProcAddr( instance, "vkBindOpticalFlowSessionImageNV" ) );
vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetInstanceProcAddr( instance, "vkCmdOpticalFlowExecuteNV" ) );
//=== VK_KHR_maintenance5 ===
vkCmdBindIndexBuffer2KHR = PFN_vkCmdBindIndexBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer2KHR" ) );
vkGetRenderingAreaGranularityKHR = PFN_vkGetRenderingAreaGranularityKHR( vkGetInstanceProcAddr( instance, "vkGetRenderingAreaGranularityKHR" ) );
vkGetDeviceImageSubresourceLayoutKHR =
PFN_vkGetDeviceImageSubresourceLayoutKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSubresourceLayoutKHR" ) );
vkGetImageSubresourceLayout2KHR = PFN_vkGetImageSubresourceLayout2KHR( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout2KHR" ) );
//=== VK_AMD_anti_lag ===
vkAntiLagUpdateAMD = PFN_vkAntiLagUpdateAMD( vkGetInstanceProcAddr( instance, "vkAntiLagUpdateAMD" ) );
//=== VK_EXT_shader_object ===
vkCreateShadersEXT = PFN_vkCreateShadersEXT( vkGetInstanceProcAddr( instance, "vkCreateShadersEXT" ) );
vkDestroyShaderEXT = PFN_vkDestroyShaderEXT( vkGetInstanceProcAddr( instance, "vkDestroyShaderEXT" ) );
vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetInstanceProcAddr( instance, "vkGetShaderBinaryDataEXT" ) );
vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindShadersEXT" ) );
//=== VK_QCOM_tile_properties ===
vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetFramebufferTilePropertiesQCOM" ) );
vkGetDynamicRenderingTilePropertiesQCOM =
PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetDynamicRenderingTilePropertiesQCOM" ) );
//=== VK_NV_low_latency2 ===
vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetInstanceProcAddr( instance, "vkSetLatencySleepModeNV" ) );
vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetInstanceProcAddr( instance, "vkLatencySleepNV" ) );
vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetInstanceProcAddr( instance, "vkSetLatencyMarkerNV" ) );
vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetInstanceProcAddr( instance, "vkGetLatencyTimingsNV" ) );
vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetInstanceProcAddr( instance, "vkQueueNotifyOutOfBandNV" ) );
//=== VK_KHR_cooperative_matrix ===
vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR =
PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR" ) );
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
vkCmdSetAttachmentFeedbackLoopEnableEXT =
PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAttachmentFeedbackLoopEnableEXT" ) );
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_external_memory_screen_buffer ===
vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetInstanceProcAddr( instance, "vkGetScreenBufferPropertiesQNX" ) );
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_KHR_line_rasterization ===
vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleKHR" ) );
//=== VK_KHR_calibrated_timestamps ===
vkGetPhysicalDeviceCalibrateableTimeDomainsKHR =
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR" ) );
vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsKHR" ) );
//=== VK_KHR_maintenance6 ===
vkCmdBindDescriptorSets2KHR = PFN_vkCmdBindDescriptorSets2KHR( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets2KHR" ) );
vkCmdPushConstants2KHR = PFN_vkCmdPushConstants2KHR( vkGetInstanceProcAddr( instance, "vkCmdPushConstants2KHR" ) );
vkCmdPushDescriptorSet2KHR = PFN_vkCmdPushDescriptorSet2KHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSet2KHR" ) );
vkCmdPushDescriptorSetWithTemplate2KHR =
PFN_vkCmdPushDescriptorSetWithTemplate2KHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplate2KHR" ) );
vkCmdSetDescriptorBufferOffsets2EXT = PFN_vkCmdSetDescriptorBufferOffsets2EXT( vkGetInstanceProcAddr( instance, "vkCmdSetDescriptorBufferOffsets2EXT" ) );
vkCmdBindDescriptorBufferEmbeddedSamplers2EXT =
PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) );
}
void init( VULKAN_HPP_NAMESPACE::Device deviceCpp ) VULKAN_HPP_NOEXCEPT
{
VkDevice device = static_cast<VkDevice>( deviceCpp );
//=== VK_VERSION_1_0 ===
vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) );
vkDestroyDevice = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) );
vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) );
vkQueueSubmit = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) );
vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) );
vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) );
vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) );
vkFreeMemory = PFN_vkFreeMemory( vkGetDeviceProcAddr( device, "vkFreeMemory" ) );
vkMapMemory = PFN_vkMapMemory( vkGetDeviceProcAddr( device, "vkMapMemory" ) );
vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) );
vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) );
vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) );
vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) );
vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) );
vkBindImageMemory = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) );
vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) );
vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) );
vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) );
vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) );
vkCreateFence = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) );
vkDestroyFence = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) );
vkResetFences = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) );
vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) );
vkWaitForFences = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) );
vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) );
vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) );
vkCreateEvent = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) );
vkDestroyEvent = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) );
vkGetEventStatus = PFN_vkGetEventStatus( vkGetDeviceProcAddr( device, "vkGetEventStatus" ) );
vkSetEvent = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) );
vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) );
vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) );
vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) );
vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) );
vkCreateBuffer = PFN_vkCreateBuffer( vkGetDeviceProcAddr( device, "vkCreateBuffer" ) );
vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) );
vkCreateBufferView = PFN_vkCreateBufferView( vkGetDeviceProcAddr( device, "vkCreateBufferView" ) );
vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) );
vkCreateImage = PFN_vkCreateImage( vkGetDeviceProcAddr( device, "vkCreateImage" ) );
vkDestroyImage = PFN_vkDestroyImage( vkGetDeviceProcAddr( device, "vkDestroyImage" ) );
vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) );
vkCreateImageView = PFN_vkCreateImageView( vkGetDeviceProcAddr( device, "vkCreateImageView" ) );
vkDestroyImageView = PFN_vkDestroyImageView( vkGetDeviceProcAddr( device, "vkDestroyImageView" ) );
vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) );
vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) );
vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) );
vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) );
vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) );
vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) );
vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) );
vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) );
vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) );
vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) );
vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) );
vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) );
vkDestroySampler = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) );
vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) );
vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) );
vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) );
vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) );
vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) );
vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) );
vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) );
vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) );
vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) );
vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) );
vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) );
vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) );
vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) );
vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) );
vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) );
vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) );
vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) );
vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) );
vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) );
vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) );
vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) );
vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) );
vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) );
vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) );
vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) );
vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) );
vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) );
vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) );
vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) );
vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) );
vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) );
vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) );
vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) );
vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) );
vkCmdDraw = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) );
vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) );
vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) );
vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) );
vkCmdDispatch = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) );
vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) );
vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) );
vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) );
vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) );
vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) );
vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) );
vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) );
vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) );
vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) );
vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) );
vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) );
vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) );
vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) );
vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) );
vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) );
vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) );
vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) );
vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) );
vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) );
vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) );
vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) );
vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) );
vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) );
vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) );
vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) );
vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) );
//=== VK_VERSION_1_1 ===
vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) );
vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) );
vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) );
vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) );
vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) );
vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) );
vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) );
vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) );
vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) );
vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) );
vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) );
vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) );
vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) );
vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) );
vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) );
vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) );
//=== VK_VERSION_1_2 ===
vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) );
vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) );
vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) );
vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) );
vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) );
vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) );
vkResetQueryPool = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) );
vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) );
vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) );
vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) );
vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) );
vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) );
vkGetDeviceMemoryOpaqueCaptureAddress =
PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
//=== VK_VERSION_1_3 ===
vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlot" ) );
vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlot" ) );
vkSetPrivateData = PFN_vkSetPrivateData( vkGetDeviceProcAddr( device, "vkSetPrivateData" ) );
vkGetPrivateData = PFN_vkGetPrivateData( vkGetDeviceProcAddr( device, "vkGetPrivateData" ) );
vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetDeviceProcAddr( device, "vkCmdSetEvent2" ) );
vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetDeviceProcAddr( device, "vkCmdResetEvent2" ) );
vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2" ) );
vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2" ) );
vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2" ) );
vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetDeviceProcAddr( device, "vkQueueSubmit2" ) );
vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2" ) );
vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetDeviceProcAddr( device, "vkCmdCopyImage2" ) );
vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2" ) );
vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2" ) );
vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetDeviceProcAddr( device, "vkCmdBlitImage2" ) );
vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetDeviceProcAddr( device, "vkCmdResolveImage2" ) );
vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetDeviceProcAddr( device, "vkCmdBeginRendering" ) );
vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetDeviceProcAddr( device, "vkCmdEndRendering" ) );
vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetDeviceProcAddr( device, "vkCmdSetCullMode" ) );
vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetDeviceProcAddr( device, "vkCmdSetFrontFace" ) );
vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopology" ) );
vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCount" ) );
vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCount" ) );
vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2" ) );
vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnable" ) );
vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnable" ) );
vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOp" ) );
vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnable" ) );
vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnable" ) );
vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetDeviceProcAddr( device, "vkCmdSetStencilOp" ) );
vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnable" ) );
vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnable" ) );
vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnable" ) );
vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirements" ) );
vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirements" ) );
vkGetDeviceImageSparseMemoryRequirements =
PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirements" ) );
//=== VK_KHR_swapchain ===
vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) );
vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) );
vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) );
vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) );
vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) );
vkGetDeviceGroupPresentCapabilitiesKHR =
PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
vkGetDeviceGroupSurfacePresentModesKHR =
PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) );
//=== VK_KHR_display_swapchain ===
vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) );
//=== VK_EXT_debug_marker ===
vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) );
vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) );
vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) );
vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) );
vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) );
//=== VK_KHR_video_queue ===
vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ) );
vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ) );
vkGetVideoSessionMemoryRequirementsKHR =
PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ) );
vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ) );
vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ) );
vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ) );
vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ) );
vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ) );
vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ) );
vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ) );
//=== VK_KHR_video_decode_queue ===
vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ) );
//=== VK_EXT_transform_feedback ===
vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) );
vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) );
vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) );
vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) );
vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) );
vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) );
//=== VK_NVX_binary_import ===
vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetDeviceProcAddr( device, "vkCreateCuModuleNVX" ) );
vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetDeviceProcAddr( device, "vkCreateCuFunctionNVX" ) );
vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetDeviceProcAddr( device, "vkDestroyCuModuleNVX" ) );
vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetDeviceProcAddr( device, "vkDestroyCuFunctionNVX" ) );
vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) );
//=== VK_NVX_image_view_handle ===
vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) );
vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) );
//=== VK_AMD_draw_indirect_count ===
vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) );
if ( !vkCmdDrawIndirectCount )
vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD;
vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) );
if ( !vkCmdDrawIndexedIndirectCount )
vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD;
//=== VK_AMD_shader_info ===
vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) );
//=== VK_KHR_dynamic_rendering ===
vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderingKHR" ) );
if ( !vkCmdBeginRendering )
vkCmdBeginRendering = vkCmdBeginRenderingKHR;
vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderingKHR" ) );
if ( !vkCmdEndRendering )
vkCmdEndRendering = vkCmdEndRenderingKHR;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_external_memory_win32 ===
vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_device_group ===
vkGetDeviceGroupPeerMemoryFeaturesKHR =
PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) );
if ( !vkGetDeviceGroupPeerMemoryFeatures )
vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR;
vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) );
if ( !vkCmdSetDeviceMask )
vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR;
vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) );
if ( !vkCmdDispatchBase )
vkCmdDispatchBase = vkCmdDispatchBaseKHR;
//=== VK_KHR_maintenance1 ===
vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) );
if ( !vkTrimCommandPool )
vkTrimCommandPool = vkTrimCommandPoolKHR;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_memory_win32 ===
vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) );
vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_memory_fd ===
vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) );
vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) );
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_semaphore_win32 ===
vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) );
vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_semaphore_fd ===
vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) );
vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) );
//=== VK_KHR_push_descriptor ===
vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) );
vkCmdPushDescriptorSetWithTemplateKHR =
PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) );
//=== VK_EXT_conditional_rendering ===
vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) );
vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) );
//=== VK_KHR_descriptor_update_template ===
vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) );
if ( !vkCreateDescriptorUpdateTemplate )
vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR;
vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) );
if ( !vkDestroyDescriptorUpdateTemplate )
vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR;
vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) );
if ( !vkUpdateDescriptorSetWithTemplate )
vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR;
//=== VK_NV_clip_space_w_scaling ===
vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) );
//=== VK_EXT_display_control ===
vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) );
vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) );
vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) );
vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) );
//=== VK_GOOGLE_display_timing ===
vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) );
vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) );
//=== VK_EXT_discard_rectangles ===
vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) );
vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEnableEXT" ) );
vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleModeEXT" ) );
//=== VK_EXT_hdr_metadata ===
vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) );
//=== VK_KHR_create_renderpass2 ===
vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) );
if ( !vkCreateRenderPass2 )
vkCreateRenderPass2 = vkCreateRenderPass2KHR;
vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) );
if ( !vkCmdBeginRenderPass2 )
vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR;
vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) );
if ( !vkCmdNextSubpass2 )
vkCmdNextSubpass2 = vkCmdNextSubpass2KHR;
vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) );
if ( !vkCmdEndRenderPass2 )
vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR;
//=== VK_KHR_shared_presentable_image ===
vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) );
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_fence_win32 ===
vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) );
vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_fence_fd ===
vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) );
vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) );
//=== VK_KHR_performance_query ===
vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) );
vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) );
//=== VK_EXT_debug_utils ===
vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) );
vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) );
vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) );
vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) );
vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) );
vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) );
vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) );
vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) );
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_ANDROID_external_memory_android_hardware_buffer ===
vkGetAndroidHardwareBufferPropertiesANDROID =
PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) );
vkGetMemoryAndroidHardwareBufferANDROID =
PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) );
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_shader_enqueue ===
vkCreateExecutionGraphPipelinesAMDX = PFN_vkCreateExecutionGraphPipelinesAMDX( vkGetDeviceProcAddr( device, "vkCreateExecutionGraphPipelinesAMDX" ) );
vkGetExecutionGraphPipelineScratchSizeAMDX =
PFN_vkGetExecutionGraphPipelineScratchSizeAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineScratchSizeAMDX" ) );
vkGetExecutionGraphPipelineNodeIndexAMDX =
PFN_vkGetExecutionGraphPipelineNodeIndexAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineNodeIndexAMDX" ) );
vkCmdInitializeGraphScratchMemoryAMDX =
PFN_vkCmdInitializeGraphScratchMemoryAMDX( vkGetDeviceProcAddr( device, "vkCmdInitializeGraphScratchMemoryAMDX" ) );
vkCmdDispatchGraphAMDX = PFN_vkCmdDispatchGraphAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphAMDX" ) );
vkCmdDispatchGraphIndirectAMDX = PFN_vkCmdDispatchGraphIndirectAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectAMDX" ) );
vkCmdDispatchGraphIndirectCountAMDX = PFN_vkCmdDispatchGraphIndirectCountAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectCountAMDX" ) );
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_sample_locations ===
vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) );
//=== VK_KHR_get_memory_requirements2 ===
vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) );
if ( !vkGetImageMemoryRequirements2 )
vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR;
vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) );
if ( !vkGetBufferMemoryRequirements2 )
vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR;
vkGetImageSparseMemoryRequirements2KHR =
PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) );
if ( !vkGetImageSparseMemoryRequirements2 )
vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR;
//=== VK_KHR_acceleration_structure ===
vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureKHR" ) );
vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureKHR" ) );
vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresKHR" ) );
vkCmdBuildAccelerationStructuresIndirectKHR =
PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresIndirectKHR" ) );
vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkBuildAccelerationStructuresKHR" ) );
vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureKHR" ) );
vkCopyAccelerationStructureToMemoryKHR =
PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureToMemoryKHR" ) );
vkCopyMemoryToAccelerationStructureKHR =
PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyMemoryToAccelerationStructureKHR" ) );
vkWriteAccelerationStructuresPropertiesKHR =
PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkWriteAccelerationStructuresPropertiesKHR" ) );
vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureKHR" ) );
vkCmdCopyAccelerationStructureToMemoryKHR =
PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureToMemoryKHR" ) );
vkCmdCopyMemoryToAccelerationStructureKHR =
PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToAccelerationStructureKHR" ) );
vkGetAccelerationStructureDeviceAddressKHR =
PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureDeviceAddressKHR" ) );
vkCmdWriteAccelerationStructuresPropertiesKHR =
PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) );
vkGetDeviceAccelerationStructureCompatibilityKHR =
PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetDeviceProcAddr( device, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) );
vkGetAccelerationStructureBuildSizesKHR =
PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureBuildSizesKHR" ) );
//=== VK_KHR_ray_tracing_pipeline ===
vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysKHR" ) );
vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesKHR" ) );
vkGetRayTracingShaderGroupHandlesKHR = PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesKHR" ) );
vkGetRayTracingCaptureReplayShaderGroupHandlesKHR =
PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) );
vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirectKHR" ) );
vkGetRayTracingShaderGroupStackSizeKHR =
PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupStackSizeKHR" ) );
vkCmdSetRayTracingPipelineStackSizeKHR =
PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetDeviceProcAddr( device, "vkCmdSetRayTracingPipelineStackSizeKHR" ) );
//=== VK_KHR_sampler_ycbcr_conversion ===
vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) );
if ( !vkCreateSamplerYcbcrConversion )
vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR;
vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) );
if ( !vkDestroySamplerYcbcrConversion )
vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR;
//=== VK_KHR_bind_memory2 ===
vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) );
if ( !vkBindBufferMemory2 )
vkBindBufferMemory2 = vkBindBufferMemory2KHR;
vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) );
if ( !vkBindImageMemory2 )
vkBindImageMemory2 = vkBindImageMemory2KHR;
//=== VK_EXT_image_drm_format_modifier ===
vkGetImageDrmFormatModifierPropertiesEXT =
PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
//=== VK_EXT_validation_cache ===
vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) );
vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) );
vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) );
vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) );
//=== VK_NV_shading_rate_image ===
vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) );
vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) );
vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) );
//=== VK_NV_ray_tracing ===
vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) );
vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) );
vkGetAccelerationStructureMemoryRequirementsNV =
PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) );
vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) );
vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) );
vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) );
vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) );
vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) );
vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) );
if ( !vkGetRayTracingShaderGroupHandlesKHR )
vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV;
vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) );
vkCmdWriteAccelerationStructuresPropertiesNV =
PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) );
//=== VK_KHR_maintenance3 ===
vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) );
if ( !vkGetDescriptorSetLayoutSupport )
vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR;
//=== VK_KHR_draw_indirect_count ===
vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) );
if ( !vkCmdDrawIndirectCount )
vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR;
vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) );
if ( !vkCmdDrawIndexedIndirectCount )
vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR;
//=== VK_EXT_external_memory_host ===
vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) );
//=== VK_AMD_buffer_marker ===
vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) );
//=== VK_EXT_calibrated_timestamps ===
vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) );
if ( !vkGetCalibratedTimestampsKHR )
vkGetCalibratedTimestampsKHR = vkGetCalibratedTimestampsEXT;
//=== VK_NV_mesh_shader ===
vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) );
vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) );
vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) );
//=== VK_NV_scissor_exclusive ===
vkCmdSetExclusiveScissorEnableNV = PFN_vkCmdSetExclusiveScissorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorEnableNV" ) );
vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) );
//=== VK_NV_device_diagnostic_checkpoints ===
vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) );
vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) );
//=== VK_KHR_timeline_semaphore ===
vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValueKHR" ) );
if ( !vkGetSemaphoreCounterValue )
vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR;
vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) );
if ( !vkWaitSemaphores )
vkWaitSemaphores = vkWaitSemaphoresKHR;
vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) );
if ( !vkSignalSemaphore )
vkSignalSemaphore = vkSignalSemaphoreKHR;
//=== VK_INTEL_performance_query ===
vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) );
vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) );
vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) );
vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) );
vkAcquirePerformanceConfigurationINTEL =
PFN_vkAcquirePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) );
vkReleasePerformanceConfigurationINTEL =
PFN_vkReleasePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) );
vkQueueSetPerformanceConfigurationINTEL =
PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) );
vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) );
//=== VK_AMD_display_native_hdr ===
vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) );
//=== VK_KHR_fragment_shading_rate ===
vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) );
//=== VK_KHR_dynamic_rendering_local_read ===
vkCmdSetRenderingAttachmentLocationsKHR =
PFN_vkCmdSetRenderingAttachmentLocationsKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingAttachmentLocationsKHR" ) );
vkCmdSetRenderingInputAttachmentIndicesKHR =
PFN_vkCmdSetRenderingInputAttachmentIndicesKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingInputAttachmentIndicesKHR" ) );
//=== VK_EXT_buffer_device_address ===
vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) );
if ( !vkGetBufferDeviceAddress )
vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT;
//=== VK_KHR_present_wait ===
vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetDeviceProcAddr( device, "vkWaitForPresentKHR" ) );
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_EXT_full_screen_exclusive ===
vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) );
vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) );
vkGetDeviceGroupSurfacePresentModes2EXT =
PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) );
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_buffer_device_address ===
vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressKHR" ) );
if ( !vkGetBufferDeviceAddress )
vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR;
vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddressKHR" ) );
if ( !vkGetBufferOpaqueCaptureAddress )
vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR;
vkGetDeviceMemoryOpaqueCaptureAddressKHR =
PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) );
if ( !vkGetDeviceMemoryOpaqueCaptureAddress )
vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR;
//=== VK_EXT_line_rasterization ===
vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) );
if ( !vkCmdSetLineStippleKHR )
vkCmdSetLineStippleKHR = vkCmdSetLineStippleEXT;
//=== VK_EXT_host_query_reset ===
vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) );
if ( !vkResetQueryPool )
vkResetQueryPool = vkResetQueryPoolEXT;
//=== VK_EXT_extended_dynamic_state ===
vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) );
if ( !vkCmdSetCullMode )
vkCmdSetCullMode = vkCmdSetCullModeEXT;
vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) );
if ( !vkCmdSetFrontFace )
vkCmdSetFrontFace = vkCmdSetFrontFaceEXT;
vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) );
if ( !vkCmdSetPrimitiveTopology )
vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT;
vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCountEXT" ) );
if ( !vkCmdSetViewportWithCount )
vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT;
vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCountEXT" ) );
if ( !vkCmdSetScissorWithCount )
vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT;
vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2EXT" ) );
if ( !vkCmdBindVertexBuffers2 )
vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT;
vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) );
if ( !vkCmdSetDepthTestEnable )
vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT;
vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) );
if ( !vkCmdSetDepthWriteEnable )
vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT;
vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOpEXT" ) );
if ( !vkCmdSetDepthCompareOp )
vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT;
vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) );
if ( !vkCmdSetDepthBoundsTestEnable )
vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT;
vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnableEXT" ) );
if ( !vkCmdSetStencilTestEnable )
vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT;
vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilOpEXT" ) );
if ( !vkCmdSetStencilOp )
vkCmdSetStencilOp = vkCmdSetStencilOpEXT;
//=== VK_KHR_deferred_host_operations ===
vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkCreateDeferredOperationKHR" ) );
vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkDestroyDeferredOperationKHR" ) );
vkGetDeferredOperationMaxConcurrencyKHR =
PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationMaxConcurrencyKHR" ) );
vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationResultKHR" ) );
vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetDeviceProcAddr( device, "vkDeferredOperationJoinKHR" ) );
//=== VK_KHR_pipeline_executable_properties ===
vkGetPipelineExecutablePropertiesKHR = PFN_vkGetPipelineExecutablePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) );
vkGetPipelineExecutableStatisticsKHR = PFN_vkGetPipelineExecutableStatisticsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) );
vkGetPipelineExecutableInternalRepresentationsKHR =
PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
//=== VK_EXT_host_image_copy ===
vkCopyMemoryToImageEXT = PFN_vkCopyMemoryToImageEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToImageEXT" ) );
vkCopyImageToMemoryEXT = PFN_vkCopyImageToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyImageToMemoryEXT" ) );
vkCopyImageToImageEXT = PFN_vkCopyImageToImageEXT( vkGetDeviceProcAddr( device, "vkCopyImageToImageEXT" ) );
vkTransitionImageLayoutEXT = PFN_vkTransitionImageLayoutEXT( vkGetDeviceProcAddr( device, "vkTransitionImageLayoutEXT" ) );
vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2EXT" ) );
if ( !vkGetImageSubresourceLayout2KHR )
vkGetImageSubresourceLayout2KHR = vkGetImageSubresourceLayout2EXT;
//=== VK_KHR_map_memory2 ===
vkMapMemory2KHR = PFN_vkMapMemory2KHR( vkGetDeviceProcAddr( device, "vkMapMemory2KHR" ) );
vkUnmapMemory2KHR = PFN_vkUnmapMemory2KHR( vkGetDeviceProcAddr( device, "vkUnmapMemory2KHR" ) );
//=== VK_EXT_swapchain_maintenance1 ===
vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesEXT" ) );
//=== VK_NV_device_generated_commands ===
vkGetGeneratedCommandsMemoryRequirementsNV =
PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsNV" ) );
vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsNV" ) );
vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsNV" ) );
vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetDeviceProcAddr( device, "vkCmdBindPipelineShaderGroupNV" ) );
vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNV" ) );
vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNV" ) );
//=== VK_EXT_depth_bias_control ===
vkCmdSetDepthBias2EXT = PFN_vkCmdSetDepthBias2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias2EXT" ) );
//=== VK_EXT_private_data ===
vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlotEXT" ) );
if ( !vkCreatePrivateDataSlot )
vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT;
vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlotEXT" ) );
if ( !vkDestroyPrivateDataSlot )
vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT;
vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkSetPrivateDataEXT" ) );
if ( !vkSetPrivateData )
vkSetPrivateData = vkSetPrivateDataEXT;
vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkGetPrivateDataEXT" ) );
if ( !vkGetPrivateData )
vkGetPrivateData = vkGetPrivateDataEXT;
//=== VK_KHR_video_encode_queue ===
vkGetEncodedVideoSessionParametersKHR =
PFN_vkGetEncodedVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkGetEncodedVideoSessionParametersKHR" ) );
vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ) );
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_cuda_kernel_launch ===
vkCreateCudaModuleNV = PFN_vkCreateCudaModuleNV( vkGetDeviceProcAddr( device, "vkCreateCudaModuleNV" ) );
vkGetCudaModuleCacheNV = PFN_vkGetCudaModuleCacheNV( vkGetDeviceProcAddr( device, "vkGetCudaModuleCacheNV" ) );
vkCreateCudaFunctionNV = PFN_vkCreateCudaFunctionNV( vkGetDeviceProcAddr( device, "vkCreateCudaFunctionNV" ) );
vkDestroyCudaModuleNV = PFN_vkDestroyCudaModuleNV( vkGetDeviceProcAddr( device, "vkDestroyCudaModuleNV" ) );
vkDestroyCudaFunctionNV = PFN_vkDestroyCudaFunctionNV( vkGetDeviceProcAddr( device, "vkDestroyCudaFunctionNV" ) );
vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetDeviceProcAddr( device, "vkCmdCudaLaunchKernelNV" ) );
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_objects ===
vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ) );
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_KHR_synchronization2 ===
vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdSetEvent2KHR" ) );
if ( !vkCmdSetEvent2 )
vkCmdSetEvent2 = vkCmdSetEvent2KHR;
vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdResetEvent2KHR" ) );
if ( !vkCmdResetEvent2 )
vkCmdResetEvent2 = vkCmdResetEvent2KHR;
vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2KHR" ) );
if ( !vkCmdWaitEvents2 )
vkCmdWaitEvents2 = vkCmdWaitEvents2KHR;
vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2KHR" ) );
if ( !vkCmdPipelineBarrier2 )
vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR;
vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2KHR" ) );
if ( !vkCmdWriteTimestamp2 )
vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR;
vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetDeviceProcAddr( device, "vkQueueSubmit2KHR" ) );
if ( !vkQueueSubmit2 )
vkQueueSubmit2 = vkQueueSubmit2KHR;
vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarker2AMD" ) );
vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointData2NV" ) );
//=== VK_EXT_descriptor_buffer ===
vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSizeEXT" ) );
vkGetDescriptorSetLayoutBindingOffsetEXT =
PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) );
vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorEXT" ) );
vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBuffersEXT" ) );
vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsetsEXT" ) );
vkCmdBindDescriptorBufferEmbeddedSamplersEXT =
PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) );
vkGetBufferOpaqueCaptureDescriptorDataEXT =
PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) );
vkGetImageOpaqueCaptureDescriptorDataEXT =
PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) );
vkGetImageViewOpaqueCaptureDescriptorDataEXT =
PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) );
vkGetSamplerOpaqueCaptureDescriptorDataEXT =
PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) );
vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
vkGetDeviceProcAddr( device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) );
//=== VK_NV_fragment_shading_rate_enums ===
vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) );
//=== VK_EXT_mesh_shader ===
vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksEXT" ) );
vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectEXT" ) );
vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountEXT" ) );
//=== VK_KHR_copy_commands2 ===
vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2KHR" ) );
if ( !vkCmdCopyBuffer2 )
vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR;
vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImage2KHR" ) );
if ( !vkCmdCopyImage2 )
vkCmdCopyImage2 = vkCmdCopyImage2KHR;
vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2KHR" ) );
if ( !vkCmdCopyBufferToImage2 )
vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR;
vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2KHR" ) );
if ( !vkCmdCopyImageToBuffer2 )
vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR;
vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetDeviceProcAddr( device, "vkCmdBlitImage2KHR" ) );
if ( !vkCmdBlitImage2 )
vkCmdBlitImage2 = vkCmdBlitImage2KHR;
vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetDeviceProcAddr( device, "vkCmdResolveImage2KHR" ) );
if ( !vkCmdResolveImage2 )
vkCmdResolveImage2 = vkCmdResolveImage2KHR;
//=== VK_EXT_device_fault ===
vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetDeviceProcAddr( device, "vkGetDeviceFaultInfoEXT" ) );
//=== VK_EXT_vertex_input_dynamic_state ===
vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetDeviceProcAddr( device, "vkCmdSetVertexInputEXT" ) );
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_external_memory ===
vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ) );
vkGetMemoryZirconHandlePropertiesFUCHSIA =
PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) );
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_external_semaphore ===
vkImportSemaphoreZirconHandleFUCHSIA = PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ) );
vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ) );
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_buffer_collection ===
vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ) );
vkSetBufferCollectionImageConstraintsFUCHSIA =
PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) );
vkSetBufferCollectionBufferConstraintsFUCHSIA =
PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) );
vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ) );
vkGetBufferCollectionPropertiesFUCHSIA =
PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ) );
#endif /*VK_USE_PLATFORM_FUCHSIA*/
//=== VK_HUAWEI_subpass_shading ===
vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI =
PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetDeviceProcAddr( device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) );
vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetDeviceProcAddr( device, "vkCmdSubpassShadingHUAWEI" ) );
//=== VK_HUAWEI_invocation_mask ===
vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetDeviceProcAddr( device, "vkCmdBindInvocationMaskHUAWEI" ) );
//=== VK_NV_external_memory_rdma ===
vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetDeviceProcAddr( device, "vkGetMemoryRemoteAddressNV" ) );
//=== VK_EXT_pipeline_properties ===
vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetPipelinePropertiesEXT" ) );
//=== VK_EXT_extended_dynamic_state2 ===
vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) );
vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) );
if ( !vkCmdSetRasterizerDiscardEnable )
vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT;
vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) );
if ( !vkCmdSetDepthBiasEnable )
vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT;
vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) );
vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) );
if ( !vkCmdSetPrimitiveRestartEnable )
vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT;
//=== VK_EXT_color_write_enable ===
vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) );
//=== VK_KHR_ray_tracing_maintenance1 ===
vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirect2KHR" ) );
//=== VK_EXT_multi_draw ===
vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiEXT" ) );
vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiIndexedEXT" ) );
//=== VK_EXT_opacity_micromap ===
vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetDeviceProcAddr( device, "vkCreateMicromapEXT" ) );
vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetDeviceProcAddr( device, "vkDestroyMicromapEXT" ) );
vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkCmdBuildMicromapsEXT" ) );
vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkBuildMicromapsEXT" ) );
vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapEXT" ) );
vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapToMemoryEXT" ) );
vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToMicromapEXT" ) );
vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkWriteMicromapsPropertiesEXT" ) );
vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapEXT" ) );
vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapToMemoryEXT" ) );
vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToMicromapEXT" ) );
vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkCmdWriteMicromapsPropertiesEXT" ) );
vkGetDeviceMicromapCompatibilityEXT = PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetDeviceProcAddr( device, "vkGetDeviceMicromapCompatibilityEXT" ) );
vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetDeviceProcAddr( device, "vkGetMicromapBuildSizesEXT" ) );
//=== VK_HUAWEI_cluster_culling_shader ===
vkCmdDrawClusterHUAWEI = PFN_vkCmdDrawClusterHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterHUAWEI" ) );
vkCmdDrawClusterIndirectHUAWEI = PFN_vkCmdDrawClusterIndirectHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterIndirectHUAWEI" ) );
//=== VK_EXT_pageable_device_local_memory ===
vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetDeviceProcAddr( device, "vkSetDeviceMemoryPriorityEXT" ) );
//=== VK_KHR_maintenance4 ===
vkGetDeviceBufferMemoryRequirementsKHR =
PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirementsKHR" ) );
if ( !vkGetDeviceBufferMemoryRequirements )
vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR;
vkGetDeviceImageMemoryRequirementsKHR =
PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirementsKHR" ) );
if ( !vkGetDeviceImageMemoryRequirements )
vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR;
vkGetDeviceImageSparseMemoryRequirementsKHR =
PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) );
if ( !vkGetDeviceImageSparseMemoryRequirements )
vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR;
//=== VK_VALVE_descriptor_set_host_mapping ===
vkGetDescriptorSetLayoutHostMappingInfoVALVE =
PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) );
vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetHostMappingVALVE" ) );
//=== VK_NV_copy_memory_indirect ===
vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectNV" ) );
vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectNV" ) );
//=== VK_NV_memory_decompression ===
vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryNV" ) );
vkCmdDecompressMemoryIndirectCountNV = PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountNV" ) );
//=== VK_NV_device_generated_commands_compute ===
vkGetPipelineIndirectMemoryRequirementsNV =
PFN_vkGetPipelineIndirectMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectMemoryRequirementsNV" ) );
vkCmdUpdatePipelineIndirectBufferNV = PFN_vkCmdUpdatePipelineIndirectBufferNV( vkGetDeviceProcAddr( device, "vkCmdUpdatePipelineIndirectBufferNV" ) );
vkGetPipelineIndirectDeviceAddressNV = PFN_vkGetPipelineIndirectDeviceAddressNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectDeviceAddressNV" ) );
//=== VK_EXT_extended_dynamic_state3 ===
vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampEnableEXT" ) );
vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetPolygonModeEXT" ) );
vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationSamplesEXT" ) );
vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleMaskEXT" ) );
vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToCoverageEnableEXT" ) );
vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToOneEnableEXT" ) );
vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEnableEXT" ) );
vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEnableEXT" ) );
vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEquationEXT" ) );
vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteMaskEXT" ) );
vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetDeviceProcAddr( device, "vkCmdSetTessellationDomainOriginEXT" ) );
vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationStreamEXT" ) );
vkCmdSetConservativeRasterizationModeEXT =
PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetConservativeRasterizationModeEXT" ) );
vkCmdSetExtraPrimitiveOverestimationSizeEXT =
PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetDeviceProcAddr( device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) );
vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipEnableEXT" ) );
vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEnableEXT" ) );
vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendAdvancedEXT" ) );
vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetProvokingVertexModeEXT" ) );
vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineRasterizationModeEXT" ) );
vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEnableEXT" ) );
vkCmdSetDepthClipNegativeOneToOneEXT = PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipNegativeOneToOneEXT" ) );
vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingEnableNV" ) );
vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportSwizzleNV" ) );
vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorEnableNV" ) );
vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorLocationNV" ) );
vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationModeNV" ) );
vkCmdSetCoverageModulationTableEnableNV =
PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableEnableNV" ) );
vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableNV" ) );
vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetShadingRateImageEnableNV" ) );
vkCmdSetRepresentativeFragmentTestEnableNV =
PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetRepresentativeFragmentTestEnableNV" ) );
vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageReductionModeNV" ) );
//=== VK_EXT_shader_module_identifier ===
vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleIdentifierEXT" ) );
vkGetShaderModuleCreateInfoIdentifierEXT =
PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleCreateInfoIdentifierEXT" ) );
//=== VK_NV_optical_flow ===
vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkCreateOpticalFlowSessionNV" ) );
vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkDestroyOpticalFlowSessionNV" ) );
vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetDeviceProcAddr( device, "vkBindOpticalFlowSessionImageNV" ) );
vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetDeviceProcAddr( device, "vkCmdOpticalFlowExecuteNV" ) );
//=== VK_KHR_maintenance5 ===
vkCmdBindIndexBuffer2KHR = PFN_vkCmdBindIndexBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer2KHR" ) );
vkGetRenderingAreaGranularityKHR = PFN_vkGetRenderingAreaGranularityKHR( vkGetDeviceProcAddr( device, "vkGetRenderingAreaGranularityKHR" ) );
vkGetDeviceImageSubresourceLayoutKHR = PFN_vkGetDeviceImageSubresourceLayoutKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSubresourceLayoutKHR" ) );
vkGetImageSubresourceLayout2KHR = PFN_vkGetImageSubresourceLayout2KHR( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2KHR" ) );
//=== VK_AMD_anti_lag ===
vkAntiLagUpdateAMD = PFN_vkAntiLagUpdateAMD( vkGetDeviceProcAddr( device, "vkAntiLagUpdateAMD" ) );
//=== VK_EXT_shader_object ===
vkCreateShadersEXT = PFN_vkCreateShadersEXT( vkGetDeviceProcAddr( device, "vkCreateShadersEXT" ) );
vkDestroyShaderEXT = PFN_vkDestroyShaderEXT( vkGetDeviceProcAddr( device, "vkDestroyShaderEXT" ) );
vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) );
vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetDeviceProcAddr( device, "vkCmdBindShadersEXT" ) );
//=== VK_QCOM_tile_properties ===
vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) );
vkGetDynamicRenderingTilePropertiesQCOM =
PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetDynamicRenderingTilePropertiesQCOM" ) );
//=== VK_NV_low_latency2 ===
vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetDeviceProcAddr( device, "vkSetLatencySleepModeNV" ) );
vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetDeviceProcAddr( device, "vkLatencySleepNV" ) );
vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetDeviceProcAddr( device, "vkSetLatencyMarkerNV" ) );
vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetDeviceProcAddr( device, "vkGetLatencyTimingsNV" ) );
vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetDeviceProcAddr( device, "vkQueueNotifyOutOfBandNV" ) );
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
vkCmdSetAttachmentFeedbackLoopEnableEXT =
PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAttachmentFeedbackLoopEnableEXT" ) );
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_external_memory_screen_buffer ===
vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetDeviceProcAddr( device, "vkGetScreenBufferPropertiesQNX" ) );
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_KHR_line_rasterization ===
vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleKHR" ) );
//=== VK_KHR_calibrated_timestamps ===
vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsKHR" ) );
//=== VK_KHR_maintenance6 ===
vkCmdBindDescriptorSets2KHR = PFN_vkCmdBindDescriptorSets2KHR( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets2KHR" ) );
vkCmdPushConstants2KHR = PFN_vkCmdPushConstants2KHR( vkGetDeviceProcAddr( device, "vkCmdPushConstants2KHR" ) );
vkCmdPushDescriptorSet2KHR = PFN_vkCmdPushDescriptorSet2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet2KHR" ) );
vkCmdPushDescriptorSetWithTemplate2KHR =
PFN_vkCmdPushDescriptorSetWithTemplate2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate2KHR" ) );
vkCmdSetDescriptorBufferOffsets2EXT = PFN_vkCmdSetDescriptorBufferOffsets2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsets2EXT" ) );
vkCmdBindDescriptorBufferEmbeddedSamplers2EXT =
PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) );
}
template <typename DynamicLoader>
void init( VULKAN_HPP_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::Device const & device, DynamicLoader const & dl ) VULKAN_HPP_NOEXCEPT
{
PFN_vkGetInstanceProcAddr getInstanceProcAddr = dl.template getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" );
PFN_vkGetDeviceProcAddr getDeviceProcAddr = dl.template getProcAddress<PFN_vkGetDeviceProcAddr>( "vkGetDeviceProcAddr" );
init( static_cast<VkInstance>( instance ), getInstanceProcAddr, static_cast<VkDevice>( device ), device ? getDeviceProcAddr : nullptr );
}
template <typename DynamicLoader
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
= VULKAN_HPP_NAMESPACE::DynamicLoader
#endif
>
void init( VULKAN_HPP_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::Device const & device ) VULKAN_HPP_NOEXCEPT
{
static DynamicLoader dl;
init( instance, device, dl );
}
};
} // namespace VULKAN_HPP_NAMESPACE
#endif
```
|
This is a list of the National Register of Historic Places listings in San Diego County, California.
This is intended to be a complete list of the properties and districts on the National Register of Historic Places in San Diego County, California, United States. Latitude and longitude coordinates are provided for many National Register properties and districts; these locations may be seen together in an online map.
There are 154 properties and districts listed on the National Register in the county, including 17 National Historic Landmarks. Another 4 properties were once listed but have been removed.
Current listings
|}
Former listings
|}
See also
California Historical Landmarks in San Diego County, California
List of San Diego Historic Landmarks
List of San Diego Historical Landmarks in La Jolla
List of San Diego Historic Landmarks in the Point Loma and Ocean Beach areas
List of National Historic Landmarks in California
References
San Diego
Buildings and structures in San Diego County, California
NRHP
National Register San Diego County
|
```java
/*
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.statement.ral.cdc;
import lombok.Getter;
import lombok.Setter;
import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.SQLParserTestCase;
import javax.xml.bind.annotation.XmlElement;
/**
* Show streaming status statement test case.
*/
@Getter
@Setter
public final class ShowStreamingStatusStatementTestCase extends SQLParserTestCase {
@XmlElement(name = "job-id")
private String jobId;
}
```
|
```objective-c
// Locale support -*- C++ -*-
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library 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
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// invalidate any other reasons why the executable file might be covered by
//
// ISO C++ 14882: 22.1 Locales
//
/** @file ctype_base.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
// Information as gleaned from /usr/include/ctype.h
_GLIBCXX_BEGIN_NAMESPACE(std)
/// @brief Base class for ctype.
struct ctype_base
{
// Non-standard typedefs.
typedef const int* __to_type;
// NB: Offsets into ctype<char>::_M_table force a particular size
// on the mask type. Because of this, we don't use an enum.
typedef unsigned short mask;
static const mask upper = _ISupper;
static const mask lower = _ISlower;
static const mask alpha = _ISalpha;
static const mask digit = _ISdigit;
static const mask xdigit = _ISxdigit;
static const mask space = _ISspace;
static const mask print = _ISprint;
static const mask graph = _ISalpha | _ISdigit | _ISpunct;
static const mask cntrl = _IScntrl;
static const mask punct = _ISpunct;
static const mask alnum = _ISalpha | _ISdigit;
};
_GLIBCXX_END_NAMESPACE
```
|
Hyposmocoma lichenalis is a species of moth of the family Cosmopterigidae. It was first described by Lord Walsingham in 1907. It is endemic to the Hawaiian island of Lanai.
External links
lichenalis
Endemic moths of Hawaii
Moths described in 1907
Taxa named by Thomas de Grey, 6th Baron Walsingham
|
```css
`vh` and `vw`, `vmin` and `vmax`
Importing a CSS file into another CSS file
At-Rules (`@`)
Use attribute selectors with empty links
Combining selectors
```
|
Clashnessie () is a small crofting community on the North-West coast of Scotland; specifically in the Assynt area of Sutherland.
The township (the old Scottish term for a crofting village) is scattered around the sandy beach of Clashnessie Bay and derives its name from the Gaelic clais an easaidh, meaning glen (clais) of the (an) waterfall (easaidh), referring to the waterfall at the head of the shallow glen in which most of the houses stand. Although north of Inverness, the village's micro-climate is generally mild, due to the closeness to the Atlantic Ocean Gulf Stream.
Today Clashnessie has just nineteen houses distributed widely over roughly a square mile area. Ten of these houses are original nineteenth-century crofters' cottages, or rebuilds, while the remaining nine are of more recent construction in a variety of styles. In the landscape around them are a number of the ruined traces of earlier dwellings and barns, the unmortared blackhouses of the crofters who were first cleared to the coast from more arable homelands in the interior. By the 1960s the resident population had fallen to around a dozen people, although within living memory Clashnessie had an inn, a post office, and a shop. The ruins of the community mill, of the kind with a horizontally mounted water-wheel, can still be seen at the side of the burn which runs down from the waterfall. The traces of the old poorhouse can still also be found on the roadside. Today the community is truly international. Although many houses have been decrofted, there has been some successful revival of traditional crofting too, with Highland cattle joining Cheviot sheep on the community's common grazing. Access to broadband has made cyber-crofting possible, which also adds to the long-term viability of the township.
References
External links
Brief details
Populated places in Sutherland
|
```php
<?php
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
*/
namespace Google\Service\DisplayVideo;
class EditGuaranteedOrderReadAccessorsRequest extends \Google\Collection
{
protected $collection_key = 'removedAdvertisers';
/**
* @var string[]
*/
public $addedAdvertisers;
/**
* @var string
*/
public $partnerId;
/**
* @var bool
*/
public $readAccessInherited;
/**
* @var string[]
*/
public $removedAdvertisers;
/**
* @param string[]
*/
public function setAddedAdvertisers($addedAdvertisers)
{
$this->addedAdvertisers = $addedAdvertisers;
}
/**
* @return string[]
*/
public function getAddedAdvertisers()
{
return $this->addedAdvertisers;
}
/**
* @param string
*/
public function setPartnerId($partnerId)
{
$this->partnerId = $partnerId;
}
/**
* @return string
*/
public function getPartnerId()
{
return $this->partnerId;
}
/**
* @param bool
*/
public function setReadAccessInherited($readAccessInherited)
{
$this->readAccessInherited = $readAccessInherited;
}
/**
* @return bool
*/
public function getReadAccessInherited()
{
return $this->readAccessInherited;
}
/**
* @param string[]
*/
public function setRemovedAdvertisers($removedAdvertisers)
{
$this->removedAdvertisers = $removedAdvertisers;
}
/**
* @return string[]
*/
public function getRemovedAdvertisers()
{
return $this->removedAdvertisers;
}
}
// Adding a class alias for backwards compatibility with the previous class name.
class_alias(EditGuaranteedOrderReadAccessorsRequest::class, your_sha256_hashest');
```
|
```javascript
/*! jQuery Validation Plugin - v1.13.1 - 10/14/2014
* path_to_url
!function(a){"function"==typeof define&&define.amd?define(["jquery","../jquery.validate.min"],a):a(jQuery)}(function(a){a.extend(a.validator.messages,{required:"Acest cmp este obligatoriu.",remote:"Te rugm s completezi acest cmp.",email:"Te rugm s introduci o adres de email valid",url:"Te rugm sa introduci o adres URL valid.",date:"Te rugm s introduci o dat corect.",dateISO:"Te rugm s introduci o dat (ISO) corect.",number:"Te rugm s introduci un numr ntreg valid.",digits:"Te rugm s introduci doar cifre.",creditcard:"Te rugm s introduci un numar de carte de credit valid.",equalTo:"Te rugm s reintroduci valoarea.",extension:"Te rugm s introduci o valoare cu o extensie valid.",maxlength:a.validator.format("Te rugm s nu introduci mai mult de {0} caractere."),minlength:a.validator.format("Te rugm s introduci cel puin {0} caractere."),rangelength:a.validator.format("Te rugm s introduci o valoare ntre {0} i {1} caractere."),range:a.validator.format("Te rugm s introduci o valoare ntre {0} i {1}."),max:a.validator.format("Te rugm s introduci o valoare egal sau mai mic dect {0}."),min:a.validator.format("Te rugm s introduci o valoare egal sau mai mare dect {0}.")})});
```
|
The Covilhã International Hill Climb, is an annual automobile hillclimb to the summit in Serra da Estrela in Covilhã, Portugal. The track measures , climbing from the start at km 31.810 on EN 339 (846 m above sea level), to the finish at km 26.570 (1300 m above the sea level), on grades averaging 9,12%.
The above paragraph uses continental not english numeric conventions and need correction
The race was on the FIA FIA International Hill Climb Cup Events Calendar and features on Portugal National Hill Climb Championships. It has taken place since 1976. It is currently contested by a variety of classes of cars, (touring cars, sportscars, single-seater).
The current record was set in 2009 by the Italian driver Simone Faggioli, on the wheel of an Osella FA 30, with the time of 2:58.839.
Winners
See also
European Hill Climb Championship
Hillclimbing
Mont Ventoux Hill Climb
Pikes Peak International Hill Climb
References
External links
- website about Czech and European hill climbs
- Most complete European Hill Climb Championship race results 1957-today by ing. Roman Krejčí
Hillclimbing
Hill climb
|
```javascript
/*!
* Bootstrap's Gruntfile
* path_to_url
*/
module.exports = function (grunt) {
'use strict';
// Force use of Unix newlines
grunt.util.linefeed = '\n';
RegExp.quote = function (string) {
return string.replace(/[-\\^$*+?.()|[\]{}]/g, '\\$&');
};
var fs = require('fs');
var path = require('path');
var generateGlyphiconsData = require('./grunt/bs-glyphicons-data-generator.js');
var BsLessdocParser = require('./grunt/bs-lessdoc-parser.js');
var getLessVarsData = function () {
var filePath = path.join(__dirname, 'less/variables.less');
var fileContent = fs.readFileSync(filePath, { encoding: 'utf8' });
var parser = new BsLessdocParser(fileContent);
return { sections: parser.parseFile() };
};
var generateRawFiles = require('./grunt/bs-raw-files-generator.js');
var generateCommonJSModule = require('./grunt/bs-commonjs-generator.js');
var configBridge = grunt.file.readJSON('./grunt/configBridge.json', { encoding: 'utf8' });
Object.keys(configBridge.paths).forEach(function (key) {
configBridge.paths[key].forEach(function (val, i, arr) {
arr[i] = path.join('./docs/assets', val);
});
});
// Project configuration.
grunt.initConfig({
// Metadata.
pkg: grunt.file.readJSON('package.json'),
banner: '/*!\n' +
' * Bootstrap v<%= pkg.version %> (<%= pkg.homepage %>)\n' +
' */\n',
jqueryCheck: configBridge.config.jqueryCheck.join('\n'),
jqueryVersionCheck: configBridge.config.jqueryVersionCheck.join('\n'),
// Task configuration.
clean: {
dist: 'dist',
docs: 'docs/dist'
},
jshint: {
options: {
jshintrc: 'js/.jshintrc'
},
grunt: {
options: {
jshintrc: 'grunt/.jshintrc'
},
src: ['Gruntfile.js', 'package.js', 'grunt/*.js']
},
core: {
src: 'js/*.js'
},
test: {
options: {
jshintrc: 'js/tests/unit/.jshintrc'
},
src: 'js/tests/unit/*.js'
},
assets: {
src: ['docs/assets/js/src/*.js', 'docs/assets/js/*.js', '!docs/assets/js/*.min.js']
}
},
jscs: {
options: {
config: 'js/.jscsrc'
},
grunt: {
src: '<%= jshint.grunt.src %>'
},
core: {
src: '<%= jshint.core.src %>'
},
test: {
src: '<%= jshint.test.src %>'
},
assets: {
options: {
requireCamelCaseOrUpperCaseIdentifiers: null
},
src: '<%= jshint.assets.src %>'
}
},
concat: {
options: {
banner: '<%= banner %>\n<%= jqueryCheck %>\n<%= jqueryVersionCheck %>',
stripBanners: false
},
bootstrap: {
src: [
'js/transition.js',
'js/alert.js',
'js/button.js',
'js/carousel.js',
'js/collapse.js',
'js/dropdown.js',
'js/modal.js',
'js/tooltip.js',
'js/popover.js',
'js/scrollspy.js',
'js/tab.js',
'js/affix.js'
],
dest: 'dist/js/<%= pkg.name %>.js'
}
},
uglify: {
options: {
compress: {
warnings: false
},
mangle: true,
preserveComments: /^!|@preserve|@license|@cc_on/i
},
core: {
src: '<%= concat.bootstrap.dest %>',
dest: 'dist/js/<%= pkg.name %>.min.js'
},
customize: {
src: configBridge.paths.customizerJs,
dest: 'docs/assets/js/customize.min.js'
},
docsJs: {
src: configBridge.paths.docsJs,
dest: 'docs/assets/js/docs.min.js'
}
},
qunit: {
options: {
inject: 'js/tests/unit/phantom.js'
},
files: 'js/tests/index.html'
},
less: {
compileCore: {
options: {
strictMath: true,
sourceMap: true,
outputSourceFiles: true,
sourceMapURL: '<%= pkg.name %>.css.map',
sourceMapFilename: 'dist/css/<%= pkg.name %>.css.map'
},
src: 'less/bootstrap.less',
dest: 'dist/css/<%= pkg.name %>.css'
},
compileTheme: {
options: {
strictMath: true,
sourceMap: true,
outputSourceFiles: true,
sourceMapURL: '<%= pkg.name %>-theme.css.map',
sourceMapFilename: 'dist/css/<%= pkg.name %>-theme.css.map'
},
src: 'less/theme.less',
dest: 'dist/css/<%= pkg.name %>-theme.css'
}
},
autoprefixer: {
options: {
browsers: configBridge.config.autoprefixerBrowsers
},
core: {
options: {
map: true
},
src: 'dist/css/<%= pkg.name %>.css'
},
theme: {
options: {
map: true
},
src: 'dist/css/<%= pkg.name %>-theme.css'
},
docs: {
src: ['docs/assets/css/src/docs.css']
},
examples: {
expand: true,
cwd: 'docs/examples/',
src: ['**/*.css'],
dest: 'docs/examples/'
}
},
csslint: {
options: {
csslintrc: 'less/.csslintrc'
},
dist: [
'dist/css/bootstrap.css',
'dist/css/bootstrap-theme.css'
],
examples: [
'docs/examples/**/*.css'
],
docs: {
options: {
ids: false,
'overqualified-elements': false
},
src: 'docs/assets/css/src/docs.css'
}
},
cssmin: {
options: {
// TODO: disable `zeroUnits` optimization once clean-css 3.2 is released
// and then simplify the fix for path_to_url accordingly
compatibility: 'ie8',
keepSpecialComments: '*',
sourceMap: true,
sourceMapInlineSources: true,
advanced: false
},
minifyCore: {
src: 'dist/css/<%= pkg.name %>.css',
dest: 'dist/css/<%= pkg.name %>.min.css'
},
minifyTheme: {
src: 'dist/css/<%= pkg.name %>-theme.css',
dest: 'dist/css/<%= pkg.name %>-theme.min.css'
},
docs: {
src: [
'docs/assets/css/ie10-viewport-bug-workaround.css',
'docs/assets/css/src/pygments-manni.css',
'docs/assets/css/src/docs.css'
],
dest: 'docs/assets/css/docs.min.css'
}
},
csscomb: {
options: {
config: 'less/.csscomb.json'
},
dist: {
expand: true,
cwd: 'dist/css/',
src: ['*.css', '!*.min.css'],
dest: 'dist/css/'
},
examples: {
expand: true,
cwd: 'docs/examples/',
src: '**/*.css',
dest: 'docs/examples/'
},
docs: {
src: 'docs/assets/css/src/docs.css',
dest: 'docs/assets/css/src/docs.css'
}
},
copy: {
fonts: {
expand: true,
src: 'fonts/**',
dest: 'dist/'
},
docs: {
expand: true,
cwd: 'dist/',
src: [
'**/*'
],
dest: 'docs/dist/'
}
},
connect: {
server: {
options: {
port: 3000,
base: '.'
}
}
},
jekyll: {
options: {
bundleExec: true,
config: '_config.yml',
incremental: false
},
docs: {},
github: {
options: {
raw: 'github: true'
}
}
},
htmlmin: {
dist: {
options: {
collapseBooleanAttributes: true,
collapseWhitespace: true,
conservativeCollapse: true,
decodeEntities: false,
minifyCSS: {
compatibility: 'ie8',
keepSpecialComments: 0
},
minifyJS: true,
minifyURLs: false,
processConditionalComments: true,
removeAttributeQuotes: true,
removeComments: true,
removeOptionalAttributes: true,
removeOptionalTags: true,
removeRedundantAttributes: true,
removeScriptTypeAttributes: true,
removeStyleLinkTypeAttributes: true,
removeTagWhitespace: false,
sortAttributes: true,
sortClassName: true
},
expand: true,
cwd: '_gh_pages',
dest: '_gh_pages',
src: [
'**/*.html',
'!examples/**/*.html'
]
}
},
pug: {
options: {
pretty: true,
data: getLessVarsData
},
customizerVars: {
src: 'docs/_pug/customizer-variables.pug',
dest: 'docs/_includes/customizer-variables.html'
},
customizerNav: {
src: 'docs/_pug/customizer-nav.pug',
dest: 'docs/_includes/nav/customize.html'
}
},
htmllint: {
options: {
ignore: [
'Attribute "autocomplete" not allowed on element "button" at this point.',
'Attribute "autocomplete" is only allowed when the input type is "color", "date", "datetime", "datetime-local", "email", "hidden", "month", "number", "password", "range", "search", "tel", "text", "time", "url", or "week".',
'Element "img" is missing required attribute "src".'
]
},
src: '_gh_pages/**/*.html'
},
watch: {
src: {
files: '<%= jshint.core.src %>',
tasks: ['jshint:core', 'qunit', 'concat']
},
test: {
files: '<%= jshint.test.src %>',
tasks: ['jshint:test', 'qunit']
},
less: {
files: 'less/**/*.less',
tasks: 'less'
}
},
'saucelabs-qunit': {
all: {
options: {
build: process.env.TRAVIS_JOB_ID,
throttled: 10,
maxRetries: 3,
maxPollRetries: 4,
urls: ['path_to_url
browsers: grunt.file.readYAML('grunt/sauce_browsers.yml')
}
}
},
exec: {
npmUpdate: {
command: 'npm update'
}
},
compress: {
main: {
options: {
archive: 'bootstrap-<%= pkg.version %>-dist.zip',
mode: 'zip',
level: 9,
pretty: true
},
files: [
{
expand: true,
cwd: 'dist/',
src: ['**'],
dest: 'bootstrap-<%= pkg.version %>-dist'
}
]
}
}
});
// These plugins provide necessary tasks.
require('load-grunt-tasks')(grunt, { scope: 'devDependencies' });
require('time-grunt')(grunt);
// Docs HTML validation task
grunt.registerTask('validate-html', ['jekyll:docs', 'htmllint']);
var runSubset = function (subset) {
return !process.env.TWBS_TEST || process.env.TWBS_TEST === subset;
};
var isUndefOrNonZero = function (val) {
return val === undefined || val !== '0';
};
// Test task.
var testSubtasks = [];
// Skip core tests if running a different subset of the test suite
if (runSubset('core') &&
// Skip core tests if this is a Savage build
process.env.TRAVIS_REPO_SLUG !== 'twbs-savage/bootstrap') {
testSubtasks = testSubtasks.concat(['dist-css', 'dist-js', 'csslint:dist', 'test-js', 'docs']);
}
// Skip HTML validation if running a different subset of the test suite
if (runSubset('validate-html') &&
// Skip HTML5 validator on Travis when [skip validator] is in the commit message
isUndefOrNonZero(process.env.TWBS_DO_VALIDATOR)) {
testSubtasks.push('validate-html');
}
// Only run Sauce Labs tests if there's a Sauce access key
if (typeof process.env.SAUCE_ACCESS_KEY !== 'undefined' &&
// Skip Sauce if running a different subset of the test suite
runSubset('sauce-js-unit') &&
// Skip Sauce on Travis when [skip sauce] is in the commit message
isUndefOrNonZero(process.env.TWBS_DO_SAUCE)) {
testSubtasks.push('connect');
testSubtasks.push('saucelabs-qunit');
}
grunt.registerTask('test', testSubtasks);
grunt.registerTask('test-js', ['jshint:core', 'jshint:test', 'jshint:grunt', 'jscs:core', 'jscs:test', 'jscs:grunt', 'qunit']);
// JS distribution task.
grunt.registerTask('dist-js', ['concat', 'uglify:core', 'commonjs']);
// CSS distribution task.
grunt.registerTask('less-compile', ['less:compileCore', 'less:compileTheme']);
grunt.registerTask('dist-css', ['less-compile', 'autoprefixer:core', 'autoprefixer:theme', 'csscomb:dist', 'cssmin:minifyCore', 'cssmin:minifyTheme']);
// Full distribution task.
grunt.registerTask('dist', ['clean:dist', 'dist-css', 'copy:fonts', 'dist-js']);
// Default task.
grunt.registerTask('default', ['clean:dist', 'copy:fonts', 'test']);
grunt.registerTask('build-glyphicons-data', function () { generateGlyphiconsData.call(this, grunt); });
// task for building customizer
grunt.registerTask('build-customizer', ['build-customizer-html', 'build-raw-files']);
grunt.registerTask('build-customizer-html', 'pug');
grunt.registerTask('build-raw-files', 'Add scripts/less files to customizer.', function () {
var banner = grunt.template.process('<%= banner %>');
generateRawFiles(grunt, banner);
});
grunt.registerTask('commonjs', 'Generate CommonJS entrypoint module in dist dir.', function () {
var srcFiles = grunt.config.get('concat.bootstrap.src');
var destFilepath = 'dist/js/npm.js';
generateCommonJSModule(grunt, srcFiles, destFilepath);
});
// Docs task.
grunt.registerTask('docs-css', ['autoprefixer:docs', 'autoprefixer:examples', 'csscomb:docs', 'csscomb:examples', 'cssmin:docs']);
grunt.registerTask('lint-docs-css', ['csslint:docs', 'csslint:examples']);
grunt.registerTask('docs-js', ['uglify:docsJs', 'uglify:customize']);
grunt.registerTask('lint-docs-js', ['jshint:assets', 'jscs:assets']);
grunt.registerTask('docs', ['docs-css', 'lint-docs-css', 'docs-js', 'lint-docs-js', 'clean:docs', 'copy:docs', 'build-glyphicons-data', 'build-customizer']);
grunt.registerTask('docs-github', ['jekyll:github', 'htmlmin']);
grunt.registerTask('prep-release', ['dist', 'docs', 'docs-github', 'compress']);
};
```
|
```python
""":mod:`numpy.ma..mrecords`
Defines the equivalent of :class:`numpy.recarrays` for masked arrays,
where fields can be accessed as attributes.
Note that :class:`numpy.ma.MaskedArray` already supports structured datatypes
and the masking of individual fields.
.. moduleauthor:: Pierre Gerard-Marchant
"""
from __future__ import division, absolute_import, print_function
# We should make sure that no field is called '_mask','mask','_fieldmask',
# or whatever restricted keywords. An idea would be to no bother in the
# first place, and then rename the invalid fields with a trailing
# underscore. Maybe we could just overload the parser function ?
import sys
import warnings
import numpy as np
import numpy.core.numerictypes as ntypes
from numpy.compat import basestring
from numpy import (
bool_, dtype, ndarray, recarray, array as narray
)
from numpy.core.records import (
fromarrays as recfromarrays, fromrecords as recfromrecords
)
_byteorderconv = np.core.records._byteorderconv
_typestr = ntypes._typestr
import numpy.ma as ma
from numpy.ma import (
MAError, MaskedArray, masked, nomask, masked_array, getdata,
getmaskarray, filled
)
_check_fill_value = ma.core._check_fill_value
__all__ = [
'MaskedRecords', 'mrecarray', 'fromarrays', 'fromrecords',
'fromtextfile', 'addfield',
]
reserved_fields = ['_data', '_mask', '_fieldmask', 'dtype']
def _getformats(data):
"""
Returns the formats of arrays in arraylist as a comma-separated string.
"""
if hasattr(data, 'dtype'):
return ",".join([desc[1] for desc in data.dtype.descr])
formats = ''
for obj in data:
obj = np.asarray(obj)
formats += _typestr[obj.dtype.type]
if issubclass(obj.dtype.type, ntypes.flexible):
formats += repr(obj.itemsize)
formats += ','
return formats[:-1]
def _checknames(descr, names=None):
"""
Checks that field names ``descr`` are not reserved keywords.
If this is the case, a default 'f%i' is substituted. If the argument
`names` is not None, updates the field names to valid names.
"""
ndescr = len(descr)
default_names = ['f%i' % i for i in range(ndescr)]
if names is None:
new_names = default_names
else:
if isinstance(names, (tuple, list)):
new_names = names
elif isinstance(names, str):
new_names = names.split(',')
else:
raise NameError("illegal input names %s" % repr(names))
nnames = len(new_names)
if nnames < ndescr:
new_names += default_names[nnames:]
ndescr = []
for (n, d, t) in zip(new_names, default_names, descr.descr):
if n in reserved_fields:
if t[0] in reserved_fields:
ndescr.append((d, t[1]))
else:
ndescr.append(t)
else:
ndescr.append((n, t[1]))
return np.dtype(ndescr)
def _get_fieldmask(self):
mdescr = [(n, '|b1') for n in self.dtype.names]
fdmask = np.empty(self.shape, dtype=mdescr)
fdmask.flat = tuple([False] * len(mdescr))
return fdmask
class MaskedRecords(MaskedArray, object):
"""
Attributes
----------
_data : recarray
Underlying data, as a record array.
_mask : boolean array
Mask of the records. A record is masked when all its fields are
masked.
_fieldmask : boolean recarray
Record array of booleans, setting the mask of each individual field
of each record.
_fill_value : record
Filling values for each field.
"""
def __new__(cls, shape, dtype=None, buf=None, offset=0, strides=None,
formats=None, names=None, titles=None,
byteorder=None, aligned=False,
mask=nomask, hard_mask=False, fill_value=None, keep_mask=True,
copy=False,
**options):
self = recarray.__new__(cls, shape, dtype=dtype, buf=buf, offset=offset,
strides=strides, formats=formats, names=names,
titles=titles, byteorder=byteorder,
aligned=aligned,)
mdtype = ma.make_mask_descr(self.dtype)
if mask is nomask or not np.size(mask):
if not keep_mask:
self._mask = tuple([False] * len(mdtype))
else:
mask = np.array(mask, copy=copy)
if mask.shape != self.shape:
(nd, nm) = (self.size, mask.size)
if nm == 1:
mask = np.resize(mask, self.shape)
elif nm == nd:
mask = np.reshape(mask, self.shape)
else:
msg = "Mask and data not compatible: data size is %i, " + \
"mask size is %i."
raise MAError(msg % (nd, nm))
copy = True
if not keep_mask:
self.__setmask__(mask)
self._sharedmask = True
else:
if mask.dtype == mdtype:
_mask = mask
else:
_mask = np.array([tuple([m] * len(mdtype)) for m in mask],
dtype=mdtype)
self._mask = _mask
return self
def __array_finalize__(self, obj):
# Make sure we have a _fieldmask by default
_mask = getattr(obj, '_mask', None)
if _mask is None:
objmask = getattr(obj, '_mask', nomask)
_dtype = ndarray.__getattribute__(self, 'dtype')
if objmask is nomask:
_mask = ma.make_mask_none(self.shape, dtype=_dtype)
else:
mdescr = ma.make_mask_descr(_dtype)
_mask = narray([tuple([m] * len(mdescr)) for m in objmask],
dtype=mdescr).view(recarray)
# Update some of the attributes
_dict = self.__dict__
_dict.update(_mask=_mask)
self._update_from(obj)
if _dict['_baseclass'] == ndarray:
_dict['_baseclass'] = recarray
return
def _getdata(self):
"""
Returns the data as a recarray.
"""
return ndarray.view(self, recarray)
_data = property(fget=_getdata)
def _getfieldmask(self):
"""
Alias to mask.
"""
return self._mask
_fieldmask = property(fget=_getfieldmask)
def __len__(self):
"""
Returns the length
"""
# We have more than one record
if self.ndim:
return len(self._data)
# We have only one record: return the nb of fields
return len(self.dtype)
def __getattribute__(self, attr):
try:
return object.__getattribute__(self, attr)
except AttributeError:
# attr must be a fieldname
pass
fielddict = ndarray.__getattribute__(self, 'dtype').fields
try:
res = fielddict[attr][:2]
except (TypeError, KeyError):
raise AttributeError("record array has no attribute %s" % attr)
# So far, so good
_localdict = ndarray.__getattribute__(self, '__dict__')
_data = ndarray.view(self, _localdict['_baseclass'])
obj = _data.getfield(*res)
if obj.dtype.fields:
raise NotImplementedError("MaskedRecords is currently limited to"
"simple records.")
# Get some special attributes
# Reset the object's mask
hasmasked = False
_mask = _localdict.get('_mask', None)
if _mask is not None:
try:
_mask = _mask[attr]
except IndexError:
# Couldn't find a mask: use the default (nomask)
pass
hasmasked = _mask.view((np.bool, (len(_mask.dtype) or 1))).any()
if (obj.shape or hasmasked):
obj = obj.view(MaskedArray)
obj._baseclass = ndarray
obj._isfield = True
obj._mask = _mask
# Reset the field values
_fill_value = _localdict.get('_fill_value', None)
if _fill_value is not None:
try:
obj._fill_value = _fill_value[attr]
except ValueError:
obj._fill_value = None
else:
obj = obj.item()
return obj
def __setattr__(self, attr, val):
"""
Sets the attribute attr to the value val.
"""
# Should we call __setmask__ first ?
if attr in ['mask', 'fieldmask']:
self.__setmask__(val)
return
# Create a shortcut (so that we don't have to call getattr all the time)
_localdict = object.__getattribute__(self, '__dict__')
# Check whether we're creating a new field
newattr = attr not in _localdict
try:
# Is attr a generic attribute ?
ret = object.__setattr__(self, attr, val)
except:
# Not a generic attribute: exit if it's not a valid field
fielddict = ndarray.__getattribute__(self, 'dtype').fields or {}
optinfo = ndarray.__getattribute__(self, '_optinfo') or {}
if not (attr in fielddict or attr in optinfo):
exctype, value = sys.exc_info()[:2]
raise exctype(value)
else:
# Get the list of names
fielddict = ndarray.__getattribute__(self, 'dtype').fields or {}
# Check the attribute
if attr not in fielddict:
return ret
if newattr:
# We just added this one or this setattr worked on an
# internal attribute.
try:
object.__delattr__(self, attr)
except:
return ret
# Let's try to set the field
try:
res = fielddict[attr][:2]
except (TypeError, KeyError):
raise AttributeError("record array has no attribute %s" % attr)
if val is masked:
_fill_value = _localdict['_fill_value']
if _fill_value is not None:
dval = _localdict['_fill_value'][attr]
else:
dval = val
mval = True
else:
dval = filled(val)
mval = getmaskarray(val)
obj = ndarray.__getattribute__(self, '_data').setfield(dval, *res)
_localdict['_mask'].__setitem__(attr, mval)
return obj
def __getitem__(self, indx):
"""
Returns all the fields sharing the same fieldname base.
The fieldname base is either `_data` or `_mask`.
"""
_localdict = self.__dict__
_mask = ndarray.__getattribute__(self, '_mask')
_data = ndarray.view(self, _localdict['_baseclass'])
# We want a field
if isinstance(indx, basestring):
# Make sure _sharedmask is True to propagate back to _fieldmask
# Don't use _set_mask, there are some copies being made that
# break propagation Don't force the mask to nomask, that wreaks
# easy masking
obj = _data[indx].view(MaskedArray)
obj._mask = _mask[indx]
obj._sharedmask = True
fval = _localdict['_fill_value']
if fval is not None:
obj._fill_value = fval[indx]
# Force to masked if the mask is True
if not obj.ndim and obj._mask:
return masked
return obj
# We want some elements.
# First, the data.
obj = np.array(_data[indx], copy=False).view(mrecarray)
obj._mask = np.array(_mask[indx], copy=False).view(recarray)
return obj
def __setitem__(self, indx, value):
"""
Sets the given record to value.
"""
MaskedArray.__setitem__(self, indx, value)
if isinstance(indx, basestring):
self._mask[indx] = ma.getmaskarray(value)
def __str__(self):
"""
Calculates the string representation.
"""
if self.size > 1:
mstr = ["(%s)" % ",".join([str(i) for i in s])
for s in zip(*[getattr(self, f) for f in self.dtype.names])]
return "[%s]" % ", ".join(mstr)
else:
mstr = ["%s" % ",".join([str(i) for i in s])
for s in zip([getattr(self, f) for f in self.dtype.names])]
return "(%s)" % ", ".join(mstr)
def __repr__(self):
"""
Calculates the repr representation.
"""
_names = self.dtype.names
fmt = "%%%is : %%s" % (max([len(n) for n in _names]) + 4,)
reprstr = [fmt % (f, getattr(self, f)) for f in self.dtype.names]
reprstr.insert(0, 'masked_records(')
reprstr.extend([fmt % (' fill_value', self.fill_value),
' )'])
return str("\n".join(reprstr))
def view(self, dtype=None, type=None):
"""
Returns a view of the mrecarray.
"""
# OK, basic copy-paste from MaskedArray.view.
if dtype is None:
if type is None:
output = ndarray.view(self)
else:
output = ndarray.view(self, type)
# Here again.
elif type is None:
try:
if issubclass(dtype, ndarray):
output = ndarray.view(self, dtype)
dtype = None
else:
output = ndarray.view(self, dtype)
# OK, there's the change
except TypeError:
dtype = np.dtype(dtype)
# we need to revert to MaskedArray, but keeping the possibility
# of subclasses (eg, TimeSeriesRecords), so we'll force a type
# set to the first parent
if dtype.fields is None:
basetype = self.__class__.__bases__[0]
output = self.__array__().view(dtype, basetype)
output._update_from(self)
else:
output = ndarray.view(self, dtype)
output._fill_value = None
else:
output = ndarray.view(self, dtype, type)
# Update the mask, just like in MaskedArray.view
if (getattr(output, '_mask', nomask) is not nomask):
mdtype = ma.make_mask_descr(output.dtype)
output._mask = self._mask.view(mdtype, ndarray)
output._mask.shape = output.shape
return output
def harden_mask(self):
"""
Forces the mask to hard.
"""
self._hardmask = True
def soften_mask(self):
"""
Forces the mask to soft
"""
self._hardmask = False
def copy(self):
"""
Returns a copy of the masked record.
"""
copied = self._data.copy().view(type(self))
copied._mask = self._mask.copy()
return copied
def tolist(self, fill_value=None):
"""
Return the data portion of the array as a list.
Data items are converted to the nearest compatible Python type.
Masked values are converted to fill_value. If fill_value is None,
the corresponding entries in the output list will be ``None``.
"""
if fill_value is not None:
return self.filled(fill_value).tolist()
result = narray(self.filled().tolist(), dtype=object)
mask = narray(self._mask.tolist())
result[mask] = None
return result.tolist()
def __getstate__(self):
"""Return the internal state of the masked array.
This is for pickling.
"""
state = (1,
self.shape,
self.dtype,
self.flags.fnc,
self._data.tobytes(),
self._mask.tobytes(),
self._fill_value,
)
return state
def __setstate__(self, state):
"""
Restore the internal state of the masked array.
This is for pickling. ``state`` is typically the output of the
``__getstate__`` output, and is a 5-tuple:
- class name
- a tuple giving the shape of the data
- a typecode for the data
- a binary string for the data
- a binary string for the mask.
"""
(ver, shp, typ, isf, raw, msk, flv) = state
ndarray.__setstate__(self, (shp, typ, isf, raw))
mdtype = dtype([(k, bool_) for (k, _) in self.dtype.descr])
self.__dict__['_mask'].__setstate__((shp, mdtype, isf, msk))
self.fill_value = flv
def __reduce__(self):
"""
Return a 3-tuple for pickling a MaskedArray.
"""
return (_mrreconstruct,
(self.__class__, self._baseclass, (0,), 'b',),
self.__getstate__())
def _mrreconstruct(subtype, baseclass, baseshape, basetype,):
"""
Build a new MaskedArray from the information stored in a pickle.
"""
_data = ndarray.__new__(baseclass, baseshape, basetype).view(subtype)
_mask = ndarray.__new__(ndarray, baseshape, 'b1')
return subtype.__new__(subtype, _data, mask=_mask, dtype=basetype,)
mrecarray = MaskedRecords
###############################################################################
# Constructors #
###############################################################################
def fromarrays(arraylist, dtype=None, shape=None, formats=None,
names=None, titles=None, aligned=False, byteorder=None,
fill_value=None):
"""
Creates a mrecarray from a (flat) list of masked arrays.
Parameters
----------
arraylist : sequence
A list of (masked) arrays. Each element of the sequence is first converted
to a masked array if needed. If a 2D array is passed as argument, it is
processed line by line
dtype : {None, dtype}, optional
Data type descriptor.
shape : {None, integer}, optional
Number of records. If None, shape is defined from the shape of the
first array in the list.
formats : {None, sequence}, optional
Sequence of formats for each individual field. If None, the formats will
be autodetected by inspecting the fields and selecting the highest dtype
possible.
names : {None, sequence}, optional
Sequence of the names of each field.
fill_value : {None, sequence}, optional
Sequence of data to be used as filling values.
Notes
-----
Lists of tuples should be preferred over lists of lists for faster processing.
"""
datalist = [getdata(x) for x in arraylist]
masklist = [np.atleast_1d(getmaskarray(x)) for x in arraylist]
_array = recfromarrays(datalist,
dtype=dtype, shape=shape, formats=formats,
names=names, titles=titles, aligned=aligned,
byteorder=byteorder).view(mrecarray)
_array._mask.flat = list(zip(*masklist))
if fill_value is not None:
_array.fill_value = fill_value
return _array
def fromrecords(reclist, dtype=None, shape=None, formats=None, names=None,
titles=None, aligned=False, byteorder=None,
fill_value=None, mask=nomask):
"""
Creates a MaskedRecords from a list of records.
Parameters
----------
reclist : sequence
A list of records. Each element of the sequence is first converted
to a masked array if needed. If a 2D array is passed as argument, it is
processed line by line
dtype : {None, dtype}, optional
Data type descriptor.
shape : {None,int}, optional
Number of records. If None, ``shape`` is defined from the shape of the
first array in the list.
formats : {None, sequence}, optional
Sequence of formats for each individual field. If None, the formats will
be autodetected by inspecting the fields and selecting the highest dtype
possible.
names : {None, sequence}, optional
Sequence of the names of each field.
fill_value : {None, sequence}, optional
Sequence of data to be used as filling values.
mask : {nomask, sequence}, optional.
External mask to apply on the data.
Notes
-----
Lists of tuples should be preferred over lists of lists for faster processing.
"""
# Grab the initial _fieldmask, if needed:
_mask = getattr(reclist, '_mask', None)
# Get the list of records.
if isinstance(reclist, ndarray):
# Make sure we don't have some hidden mask
if isinstance(reclist, MaskedArray):
reclist = reclist.filled().view(ndarray)
# Grab the initial dtype, just in case
if dtype is None:
dtype = reclist.dtype
reclist = reclist.tolist()
mrec = recfromrecords(reclist, dtype=dtype, shape=shape, formats=formats,
names=names, titles=titles,
aligned=aligned, byteorder=byteorder).view(mrecarray)
# Set the fill_value if needed
if fill_value is not None:
mrec.fill_value = fill_value
# Now, let's deal w/ the mask
if mask is not nomask:
mask = np.array(mask, copy=False)
maskrecordlength = len(mask.dtype)
if maskrecordlength:
mrec._mask.flat = mask
elif len(mask.shape) == 2:
mrec._mask.flat = [tuple(m) for m in mask]
else:
mrec.__setmask__(mask)
if _mask is not None:
mrec._mask[:] = _mask
return mrec
def _guessvartypes(arr):
"""
Tries to guess the dtypes of the str_ ndarray `arr`.
Guesses by testing element-wise conversion. Returns a list of dtypes.
The array is first converted to ndarray. If the array is 2D, the test
is performed on the first line. An exception is raised if the file is
3D or more.
"""
vartypes = []
arr = np.asarray(arr)
if len(arr.shape) == 2:
arr = arr[0]
elif len(arr.shape) > 2:
raise ValueError("The array should be 2D at most!")
# Start the conversion loop.
for f in arr:
try:
int(f)
except ValueError:
try:
float(f)
except ValueError:
try:
complex(f)
except ValueError:
vartypes.append(arr.dtype)
else:
vartypes.append(np.dtype(complex))
else:
vartypes.append(np.dtype(float))
else:
vartypes.append(np.dtype(int))
return vartypes
def openfile(fname):
"""
Opens the file handle of file `fname`.
"""
# A file handle
if hasattr(fname, 'readline'):
return fname
# Try to open the file and guess its type
try:
f = open(fname)
except IOError:
raise IOError("No such file: '%s'" % fname)
if f.readline()[:2] != "\\x":
f.seek(0, 0)
return f
f.close()
raise NotImplementedError("Wow, binary file")
def fromtextfile(fname, delimitor=None, commentchar='#', missingchar='',
varnames=None, vartypes=None):
"""
Creates a mrecarray from data stored in the file `filename`.
Parameters
----------
fname : {file name/handle}
Handle of an opened file.
delimitor : {None, string}, optional
Alphanumeric character used to separate columns in the file.
If None, any (group of) white spacestring(s) will be used.
commentchar : {'#', string}, optional
Alphanumeric character used to mark the start of a comment.
missingchar : {'', string}, optional
String indicating missing data, and used to create the masks.
varnames : {None, sequence}, optional
Sequence of the variable names. If None, a list will be created from
the first non empty line of the file.
vartypes : {None, sequence}, optional
Sequence of the variables dtypes. If None, it will be estimated from
the first non-commented line.
Ultra simple: the varnames are in the header, one line"""
# Try to open the file.
ftext = openfile(fname)
# Get the first non-empty line as the varnames
while True:
line = ftext.readline()
firstline = line[:line.find(commentchar)].strip()
_varnames = firstline.split(delimitor)
if len(_varnames) > 1:
break
if varnames is None:
varnames = _varnames
# Get the data.
_variables = masked_array([line.strip().split(delimitor) for line in ftext
if line[0] != commentchar and len(line) > 1])
(_, nfields) = _variables.shape
ftext.close()
# Try to guess the dtype.
if vartypes is None:
vartypes = _guessvartypes(_variables[0])
else:
vartypes = [np.dtype(v) for v in vartypes]
if len(vartypes) != nfields:
msg = "Attempting to %i dtypes for %i fields!"
msg += " Reverting to default."
warnings.warn(msg % (len(vartypes), nfields))
vartypes = _guessvartypes(_variables[0])
# Construct the descriptor.
mdescr = [(n, f) for (n, f) in zip(varnames, vartypes)]
mfillv = [ma.default_fill_value(f) for f in vartypes]
# Get the data and the mask.
# We just need a list of masked_arrays. It's easier to create it like that:
_mask = (_variables.T == missingchar)
_datalist = [masked_array(a, mask=m, dtype=t, fill_value=f)
for (a, m, t, f) in zip(_variables.T, _mask, vartypes, mfillv)]
return fromarrays(_datalist, dtype=mdescr)
def addfield(mrecord, newfield, newfieldname=None):
"""Adds a new field to the masked record array
Uses `newfield` as data and `newfieldname` as name. If `newfieldname`
is None, the new field name is set to 'fi', where `i` is the number of
existing fields.
"""
_data = mrecord._data
_mask = mrecord._mask
if newfieldname is None or newfieldname in reserved_fields:
newfieldname = 'f%i' % len(_data.dtype)
newfield = ma.array(newfield)
# Get the new data.
# Create a new empty recarray
newdtype = np.dtype(_data.dtype.descr + [(newfieldname, newfield.dtype)])
newdata = recarray(_data.shape, newdtype)
# Add the exisintg field
[newdata.setfield(_data.getfield(*f), *f)
for f in _data.dtype.fields.values()]
# Add the new field
newdata.setfield(newfield._data, *newdata.dtype.fields[newfieldname])
newdata = newdata.view(MaskedRecords)
# Get the new mask
# Create a new empty recarray
newmdtype = np.dtype([(n, bool_) for n in newdtype.names])
newmask = recarray(_data.shape, newmdtype)
# Add the old masks
[newmask.setfield(_mask.getfield(*f), *f)
for f in _mask.dtype.fields.values()]
# Add the mask of the new field
newmask.setfield(getmaskarray(newfield),
*newmask.dtype.fields[newfieldname])
newdata._mask = newmask
return newdata
```
|
```go
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package clipboard
import (
"runtime"
"syscall"
"time"
"unsafe"
)
const (
cfUnicodetext = 13
gmemMoveable = 0x0002
)
var (
user32 = syscall.MustLoadDLL("user32")
isClipboardFormatAvailable = user32.MustFindProc("IsClipboardFormatAvailable")
openClipboard = user32.MustFindProc("OpenClipboard")
closeClipboard = user32.MustFindProc("CloseClipboard")
emptyClipboard = user32.MustFindProc("EmptyClipboard")
getClipboardData = user32.MustFindProc("GetClipboardData")
setClipboardData = user32.MustFindProc("SetClipboardData")
kernel32 = syscall.NewLazyDLL("kernel32")
globalAlloc = kernel32.NewProc("GlobalAlloc")
globalFree = kernel32.NewProc("GlobalFree")
globalLock = kernel32.NewProc("GlobalLock")
globalUnlock = kernel32.NewProc("GlobalUnlock")
lstrcpy = kernel32.NewProc("lstrcpyW")
)
// waitOpenClipboard opens the clipboard, waiting for up to a second to do so.
func waitOpenClipboard() error {
started := time.Now()
limit := started.Add(time.Second)
var r uintptr
var err error
for time.Now().Before(limit) {
r, _, err = openClipboard.Call(0)
if r != 0 {
return nil
}
time.Sleep(time.Millisecond)
}
return err
}
func readAll() (string, error) {
// LockOSThread ensure that the whole method will keep executing on the same thread from begin to end (it actually locks the goroutine thread attribution).
// Otherwise if the goroutine switch thread during execution (which is a common practice), the OpenClipboard and CloseClipboard will happen on two different threads, and it will result in a clipboard deadlock.
runtime.LockOSThread()
defer runtime.UnlockOSThread()
if formatAvailable, _, err := isClipboardFormatAvailable.Call(cfUnicodetext); formatAvailable == 0 {
return "", err
}
err := waitOpenClipboard()
if err != nil {
return "", err
}
h, _, err := getClipboardData.Call(cfUnicodetext)
if h == 0 {
_, _, _ = closeClipboard.Call()
return "", err
}
l, _, err := globalLock.Call(h)
if l == 0 {
_, _, _ = closeClipboard.Call()
return "", err
}
text := syscall.UTF16ToString((*[1 << 20]uint16)(unsafe.Pointer(l))[:])
r, _, err := globalUnlock.Call(h)
if r == 0 {
_, _, _ = closeClipboard.Call()
return "", err
}
closed, _, err := closeClipboard.Call()
if closed == 0 {
return "", err
}
return text, nil
}
func writeAll(text string) error {
// LockOSThread ensure that the whole method will keep executing on the same thread from begin to end (it actually locks the goroutine thread attribution).
// Otherwise if the goroutine switch thread during execution (which is a common practice), the OpenClipboard and CloseClipboard will happen on two different threads, and it will result in a clipboard deadlock.
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := waitOpenClipboard()
if err != nil {
return err
}
r, _, err := emptyClipboard.Call(0)
if r == 0 {
_, _, _ = closeClipboard.Call()
return err
}
data := syscall.StringToUTF16(text)
// "If the hMem parameter identifies a memory object, the object must have
// been allocated using the function with the GMEM_MOVEABLE flag."
h, _, err := globalAlloc.Call(gmemMoveable, uintptr(len(data)*int(unsafe.Sizeof(data[0]))))
if h == 0 {
_, _, _ = closeClipboard.Call()
return err
}
defer func() {
if h != 0 {
globalFree.Call(h)
}
}()
l, _, err := globalLock.Call(h)
if l == 0 {
_, _, _ = closeClipboard.Call()
return err
}
r, _, err = lstrcpy.Call(l, uintptr(unsafe.Pointer(&data[0])))
if r == 0 {
_, _, _ = closeClipboard.Call()
return err
}
r, _, err = globalUnlock.Call(h)
if r == 0 {
if err.(syscall.Errno) != 0 {
_, _, _ = closeClipboard.Call()
return err
}
}
r, _, err = setClipboardData.Call(cfUnicodetext, h)
if r == 0 {
_, _, _ = closeClipboard.Call()
return err
}
h = 0 // suppress deferred cleanup
closed, _, err := closeClipboard.Call()
if closed == 0 {
return err
}
return nil
}
```
|
```css
How to easily check browser compatibility of a feature
Use `background-repeat` to repeat a background image horizontally or vertically
Use pseudo-elements to style specific parts of an element
Use `SVG` for icons
Debug with `*` selector
```
|
The 2022–23 Liga I is the 33rd season of the top level women's football league of the Romanian football league system. 12 teams will play a one legged-round robin. The top 6 teams progress then to the play-offs, while the bottom 6 teams to the play-out, where a two-legged round-robin will take place. Teams ranked 11 and 12 (5 and 6 in the play-out) will relegate directly to the 2023–24 Liga II.
U Olimpia Cluj are the defending champions.
Team changes
To Liga I
Promoted from Liga II
Csíkszereda Miercurea Ciuc (winner of 2021–22 Liga II, Seria I)
Carmen București (runner-up of 2021–22 Liga II, Seria II)
From Liga I
Relegated to Liga II
CSȘ Târgoviște (12th place in 2021–22 Liga I)
Dsibanded
Heniu Prundu Bârgăului (2nd place in 2021–22 Liga I)
Renamed teams
While still technically having remained a separate club for the duration of the 2021-22 season, and after using the Politehnica brand for one season, ACS Fortuna Becicherecu Mic was finally dissafiliated and the cession of participation rights in all women's football competitions to the SSU Politehnica Timișoara club was approved on 5 August 2022, finalizing a deal long in the making.
Excluded and spared teams
In the summer of 2022, Heniu Prundu Bârgăului was supposed to be taken over by the CS Gloria 2018 Bistrița-Năsăud club, which had more financial support. The move fell short due to identity issues, the main reason being the Heniu brand would have been suppressed in favor of the Gloria one. Heniu coach Călin Svoboda, along with a large part of the players opted to move to found the women's football section of Gloria 2018, while Heniu disbanded due to a combination of lack of players and financial support. As a consequence, the 11th place in the 2021-22 Liga I, Universitatea Galați was spared from relegation.
Stadiums by capacity and location
References
Rom
Fem
Romanian Superliga (women's football) seasons
|
```javascript
import {
booleanHtmlAttributes,
tagsWithoutEndTag,
tagsWithInnerContent,
tagAttributeAsInnerContent,
tagProperties,
commonDataAttributes
} from '../../shared/constants'
/**
* Generates meta, base, link, style, script, noscript tags for use on the server
*
* @param {('meta'|'base'|'link'|'style'|'script'|'noscript')} the name of the tag
* @param {(Array<Object>|Object)} tags - an array of tag objects or a single object in case of base
* @return {Object} - the tag generator
*/
export default function tagGenerator (options, type, tags, generatorOptions) {
const { ssrAppId, attribute, tagIDKeyName } = options || {}
const { appId, isSSR = true, body = false, pbody = false, ln = false } = generatorOptions || {}
const dataAttributes = [tagIDKeyName, ...commonDataAttributes]
if (!tags || !tags.length) {
return ''
}
// build a string containing all tags of this type
return tags.reduce((tagsStr, tag) => {
if (tag.skip) {
return tagsStr
}
const tagKeys = Object.keys(tag)
if (tagKeys.length === 0) {
return tagsStr // Bail on empty tag object
}
if (Boolean(tag.body) !== body || Boolean(tag.pbody) !== pbody) {
return tagsStr
}
let attrs = tag.once ? '' : ` ${attribute}="${appId || (isSSR === false ? '1' : ssrAppId)}"`
// build a string containing all attributes of this tag
for (const attr in tag) {
// these attributes are treated as children on the tag
if (tagAttributeAsInnerContent.includes(attr) || tagProperties.includes(attr)) {
continue
}
if (attr === 'callback') {
attrs += ' onload="this.__vm_l=1"'
continue
}
// these form the attribute list for this tag
let prefix = ''
if (dataAttributes.includes(attr)) {
prefix = 'data-'
}
const isBooleanAttr = !prefix && booleanHtmlAttributes.includes(attr)
if (isBooleanAttr && !tag[attr]) {
continue
}
attrs += ` ${prefix}${attr}` + (isBooleanAttr ? '' : `="${tag[attr]}"`)
}
let json = ''
if (tag.json) {
json = JSON.stringify(tag.json)
}
// grab child content from one of these attributes, if possible
const content = tag.innerHTML || tag.cssText || json
// generate tag exactly without any other redundant attribute
// these tags have no end tag
const hasEndTag = !tagsWithoutEndTag.includes(type)
// these tag types will have content inserted
const hasContent = hasEndTag && tagsWithInnerContent.includes(type)
// the final string for this specific tag
return `${tagsStr}<${type}${attrs}${!hasContent && hasEndTag ? '/' : ''}>` +
(hasContent ? `${content}</${type}>` : '') +
(ln ? '\n' : '')
}, '')
}
```
|
Albertus Dominicus Marcellinus Erasmus "Ab" Osterhaus (born 2 June 1948) is a leading Dutch virologist and influenza expert. An Emeritus Professor of Virology at Erasmus University Rotterdam since 1993, Osterhaus is known throughout the world for his work on SARS and H5N1, the pathogen that causes avian influenza.
Life
Osterhaus was born into a Roman Catholic family of seven and grew up in Slotermeer, Amsterdam. From 1967 he studied at the Utrecht University where he graduated with a degree in veterinary medicine cum laude in 1974. He then obtained his PhD degree at the same university in 1978 with a dissertation entitled Feline infectious peritonitis: identification, propagation and epidemiology.
He fulfilled several positions in his 16-year career at the Netherlands National Institute for Public Health and the Environment (RIVM) in Bilthoven, the last of which was head of the laboratory for Immunobiology. During that period he was also a part-time Professor of Environmental Virology at the Institute for Virology in Utrecht, a position he still holds as of 2009. In 1993, he became Professor of Virology at the Medical Faculty of University and also head of the Department of Virology at Erasmus University Medical Centre Rotterdam. In 2013, he stepped down from his position as head of the department of Viroscience, as the Virology department is now known, and handed over the reins to Professor Marion Koopmans, formerly attached to the Dutch National Institute of Health, the RIVM. Osterhaus did not rest and set up a new institute looking at the zoonotic side of virology at TiHo in Hannover, Germany. He also holds a position at Artemis BV in Utrecht.
Osterhaus played an important role in the identification of the SARS coronavirus. In February 2004, his team found that Pegylated interferon alpha, a drug used for the treatment of patients with Hepatitis C, helps combat the virus that causes SARS.
Osterhaus holds various editorial positions for scientific journals, holds several patents, has been supervisor of more than 40 PhD students and has identified more than a dozen “new” viral pathogens and he is author of more than 1000 scientific papers, including journals like Nature, Science and The Lancet.
Osterhaus served as member and chairman of many international scientific committees, most notably four WHO reference centres, the Dutch Influenza Centre, the Dutch Health Council and the European Scientific Working group on Influenza (ESWI).
Honours and awards
Osterhaus received several awards in his life, including the Dutch "M.W. Beijerinck Virology Award", a prize awarded triennially (before 2014, and now awarded biennially) by the Royal Netherlands Academy of Arts and Sciences in 1998. He is also a Member of Royal Netherlands Academy of Arts and Sciences (KNAW) since 2001.
On 15 October 2003 Osterhaus was knighted as Commander in the Order of the Dutch Lion. Other awards Osterhaus received include the Dutch "Dr. Saal van Zwanenberg Prijs" for pharmacotherapy, the "Reinier de Graaf Medaille" for clinical medicine, and on 13 June 2007 he was awarded the French "Grand Prix scientifique de la Fondation Louis D." of the Institut de France. He shared the €450,000 prize money with National Institute for Medical Research professor Sir John Skehel from London. In 2016 he became a member of the German Academy of Sciences Leopoldina.
Criticism
Osterhaus has been criticised for what has been described as a 'fear campaign', for exaggerating the consequences of the 2009 flu pandemic and pushing for extensive measures, even though the pandemic influenza (H1N1) is now treated as if it were a common flu. Physician and microbiologist Miquel Ekkelenkamp called Osterhaus a 'scaremonger' in an opinion piece in nrc.next and said: "'Expert' Osterhaus should be banned indefinitely from television. Everything he claimed turned out to be untrue: we're not all going to die like we did in 1918, not everyone needs a vaccination, we are not going to give Tamiflu to everyone and the virus has not mutated into something much more dangerous." Osterhaus claimed he has not exaggerated the risks. During debate 'De Kwestie live' he said "I have named a wide spectrum of possibilities and minister Ab Klink decided to go for the worst-case scenario"
In September 2009, a controversy arose when it became known Osterhaus has a 9.8% share in ViroClinics B.V, a pharmaceutical company that supposedly benefits from the 34 million vaccines Health minister Ab Klink bought based on his advice as government consultant. Osterhaus maintains he did nothing against the law and that he does not personally benefit from the order.
References
External links
Personal home page at Erasmus Medical Centre
Patents related to A.D.M.E. Osterhaus
1948 births
Living people
Influenza researchers
Male veterinarians
Dutch virologists
Scientists from Amsterdam
World Health Organization officials
2002–2004 SARS outbreak
Academic staff of Erasmus University Rotterdam
Academic staff of Utrecht University
Utrecht University alumni
Members of the Royal Netherlands Academy of Arts and Sciences
Commanders of the Order of the Netherlands Lion
Dutch veterinarians
Dutch officials of the United Nations
Members of the German National Academy of Sciences Leopoldina
|
```c++
/****************************************************************************
** All rights reserved.
** See license at path_to_url
****************************************************************************/
#include "gui_document_list_model.h"
#include "../base/application.h"
#include "../base/document.h"
#include "../gui/gui_application.h"
#include "../gui/gui_document.h"
#include "../qtcommon/filepath_conv.h"
#include "../qtcommon/qstring_conv.h"
namespace Mayo {
GuiDocumentListModel::GuiDocumentListModel(const GuiApplication* guiApp, QObject* parent)
: QAbstractListModel(parent)
{
for (const GuiDocument* doc : guiApp->guiDocuments())
this->appendGuiDocument(doc);
auto app = guiApp->application();
app->signalDocumentNameChanged.connectSlot(&GuiDocumentListModel::onDocumentNameChanged, this);
guiApp->signalGuiDocumentAdded.connectSlot(&GuiDocumentListModel::appendGuiDocument, this);
guiApp->signalGuiDocumentErased.connectSlot(&GuiDocumentListModel::removeGuiDocument, this);
}
QVariant GuiDocumentListModel::data(const QModelIndex& index, int role) const
{
if (!index.isValid() || index.row() >= this->rowCount())
return {};
const DocumentPtr& doc = m_vecGuiDocument.at(index.row())->document();
switch (role) {
case Qt::ToolTipRole:
return filepathTo<QString>(filepathCanonical(doc->filePath()));
case Qt::DisplayRole:
case Qt::EditRole:
return to_QString(doc->name());
}
return {};
}
int GuiDocumentListModel::rowCount(const QModelIndex& /*parent*/) const
{
return int(m_vecGuiDocument.size());
}
void GuiDocumentListModel::appendGuiDocument(const GuiDocument* guiDoc)
{
// NOTE: don't use rowCount() as it's virtual and appendGuiDocument() is called in constructor
// of this class(virtual dispatch would be bypassed)
const auto row = int(m_vecGuiDocument.size());
this->beginInsertRows(QModelIndex(), row, row);
m_vecGuiDocument.emplace_back(guiDoc);
this->endInsertRows();
}
void GuiDocumentListModel::removeGuiDocument(const GuiDocument* guiDoc)
{
auto itFound = std::find(m_vecGuiDocument.begin(), m_vecGuiDocument.end(), guiDoc);
if (itFound != m_vecGuiDocument.end()) {
const int row = itFound - m_vecGuiDocument.begin();
this->beginRemoveRows(QModelIndex(), row, row);
m_vecGuiDocument.erase(itFound);
this->endRemoveRows();
}
}
void GuiDocumentListModel::onDocumentNameChanged(const DocumentPtr& doc, const std::string& /*name*/)
{
auto itFound = std::find_if(
m_vecGuiDocument.cbegin(),
m_vecGuiDocument.cend(),
[&](const GuiDocument* guiDoc) { return guiDoc->document() == doc; }
);
if (itFound != m_vecGuiDocument.cend()) {
const int row = itFound - m_vecGuiDocument.begin();
const QModelIndex itemIndex = this->index(row);
emit this->dataChanged(itemIndex, itemIndex, { Qt::DisplayRole, Qt::EditRole });
}
}
} // namespace Mayo
```
|
```python
#
#
# path_to_url
#
# Unless required by applicable law or agreed to in writing, software
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
"""Defines exported symbols for the `orbit` package."""
from orbit import actions
# Internal import orbit.
from orbit import utils
from orbit.controller import Action
from orbit.controller import Controller
from orbit.runner import AbstractEvaluator
from orbit.runner import AbstractTrainer
from orbit.standard_runner import StandardEvaluator
from orbit.standard_runner import StandardEvaluatorOptions
from orbit.standard_runner import StandardTrainer
from orbit.standard_runner import StandardTrainerOptions
```
|
```css
/*
* This file is automatically generated.
* Manual changes will be lost.
*/
:root,
.ui-standard {
--primary-minor-2: #1c1633;
--primary-minor-1: #29214d;
--primary: #8a6eff;
--primary-major-1: #967dff;
--primary-major-2: #a18bff;
--primary-major-3: #ad9aff;
--primary-contrast: #ffffff;
--signal-danger-minor-2: #310b12;
--signal-danger-minor-1: #4a111b;
--signal-danger: #f5385a;
--signal-danger-major-1: #f64c6b;
--signal-danger-major-2: #f7607b;
--signal-danger-major-3: #f8748c;
--signal-danger-contrast: #ffffff;
--signal-warning-minor-2: #331200;
--signal-warning-minor-1: #4d1b00;
--signal-warning: #ff9900;
--signal-warning-major-1: #ffa31a;
--signal-warning-major-2: #ffad33;
--signal-warning-major-3: #ffb84d;
--signal-warning-contrast: #000000;
--signal-success-minor-2: #06221b;
--signal-success-minor-1: #093228;
--signal-success: #1ea885;
--signal-success-major-1: #35b191;
--signal-success-major-2: #4bb99d;
--signal-success-major-3: #62c2aa;
--signal-success-contrast: #ffffff;
--signal-info-minor-2: #072029;
--signal-info-minor-1: #0b2f3e;
--signal-info: #239ece;
--signal-info-major-1: #39a8d3;
--signal-info-major-2: #4fb1d8;
--signal-info-major-3: #65bbdd;
--signal-info-contrast: #ffffff;
--interaction-norm-minor-2: #160f33;
--interaction-norm-minor-1: #21164d;
--interaction-norm: #6d4aff;
--interaction-norm-major-1: #7c5cff;
--interaction-norm-major-2: #8a6eff;
--interaction-norm-major-3: #9980ff;
--interaction-norm-contrast: #ffffff;
--interaction-weak-minor-2: #16151a;
--interaction-weak-minor-1: #25232c;
--interaction-weak: #4a4658;
--interaction-weak-major-1: #5c5969;
--interaction-weak-major-2: #6e6b79;
--interaction-weak-major-3: #807e8a;
--interaction-weak-contrast: #ffffff;
--text-norm: white;
--text-weak: #a7a4b5;
--text-hint: #6d697d;
--text-disabled: #5b576b;
--text-invert: #1c1b24;
--field-norm: #5b576b;
--field-hover: #6d697d;
--field-disabled: #3f3b4c;
--focus-outline: #6d4aff;
--focus-ring: rgb(109 74 255 / 0.3);
--border-norm: #4a4658;
--border-weak: #343140;
--background-norm: #16141c;
--background-weak: #292733;
--background-strong: #3f3b4c;
--background-invert: white;
--interaction-default: transparent;
--interaction-default-hover: rgb(91 87 107 / 0.2);
--interaction-default-active: rgb(91 87 107 / 0.4);
--shadow-norm-opacity: 0.5;
--shadow-raised-opacity: 0.44;
--shadow-lifted-opacity: 0.75;
--backdrop-norm: rgb(0 0 0 / 0.48);
--optional-scrollbar-thumb-color: #4a4658;
--optional-link-norm: var(--interaction-norm-major-1);
--optional-link-hover: var(--interaction-norm-major-2);
--optional-link-active: var(--interaction-norm-major-3);
--optional-background-elevated: #1e1c26;
--optional-background-lowered: var(--background-norm);
--optional-email-item-read-text-color: var(--text-weak);
--optional-mini-calendar-today-color: white;
--optional-logo-text-proton-color: white;
--optional-logo-text-product-color: white;
--optional-promotion-text-color: white;
--optional-promotion-text-weak: #c1b2ff;
--optional-promotion-interaction-hover: rgb(138 110 255 / 0.2);
--optional-promotion-background-start: rgb(138 110 255 / 0.3);
--optional-promotion-background-end: rgb(99 61 255 / 0.1);
}
```
|
```python
# -*- coding: utf-8 -*-
import pytest
from skidl import Part, Net, generate_svg, TEMPLATE, KICAD, KICAD6, lib_search_paths, SubCircuit, Bus, POWER, ERC, set_default_tool
from .setup_teardown import setup_function, teardown_function
def test_svg_1():
l1 = Part("Device", "L")
r1, r2 = Part("Device", "R", dest=TEMPLATE, value="200.0") * 2
q1 = Part("Device", "Q_NPN_CBE")
c1 = Part("Device", "C", value="10pF")
r3 = r2(value="1K")
vcc, vin, vout, gnd = Net("VCC"), Net("VIN"), Net("VOUT"), Net("GND")
vcc & r1 & vin & r2 & gnd
vcc & r3 & vout & q1["C,E"] & gnd
q1["B"] += vin
vout & (l1 | c1) & gnd
rly = Part("Relay", "TE_PCH-1xxx2M")
rly[1, 2, 3, 5] += gnd
led = Part("Device", "LED_ARGB", symtx="RH")
r, g, b = Net("R"), Net("G"), Net("B")
led["A,RK,GK,BK"] += vcc, r, g, b
Part(lib="MCU_STC", name="STC15W204S-35x-SOP16")
generate_svg(file_="test1")
def test_svg_2():
# TODO: Figure out why loading a part fully parses every part in the library.
opamp = Part(lib="Amplifier_Operational", name="AD8676xR", symtx="H")
opamp.uA.p2 += Net("IN1")
opamp.uA.p3 += Net("IN2")
opamp.uA.p1 += Net("OUT")
opamp.uB.symtx = 'L'
generate_svg(file_="test2")
def test_svg_3():
gnd = Part("power", "GND")
vcc = Part("power", "VCC")
opamp = Part(lib="Amplifier_Operational", name="AD8676xR", symtx="V")
for part in default_circuit.parts:
part.validate()
vcc[1] += opamp[8]
gnd[1] += opamp[4]
r = Part("Device", "R_US", dest=TEMPLATE, tx_ops="L")
(
Net("IN")
& r(value="4K7", symtx="L")
& opamp.uA[2]
& r(value="4K7", symtx="L")
& opamp.uA[1]
)
gnd[1] += opamp.uA[3]
opamp.uA[1] & r(value="10K") & gnd[1]
for part in default_circuit.parts:
part.validate()
generate_svg()
def test_svg_4():
q = Part(lib="Device", name="Q_PNP_CBE", dest=TEMPLATE, symtx="V")
r = Part("Device", "R", dest=TEMPLATE)
gndt = Part("power", "GND")
vcct = Part("power", "VCC")
gnd = Net("GND")
vcc = Net("VCC")
gnd & gndt
vcc & vcct
a = Net("A", netio="i")
b = Net("B", netio="i")
a_and_b = Net("A_AND_B", netio="o")
q1 = q()
q1.E.symio = "i"
q1.B.symio = "i"
q1.C.symio = "o"
q2 = q()
q2.E.symio = "i"
q2.B.symio = "i"
q2.C.symio = "NC"
# q2.C.symio = "o"
r1, r2, r3, r4, r5 = r(5, value="10K")
a & r1 & q1["B", "C"] & r4 & q2["B", "C"] & a_and_b & r5 & gnd
b & r2 & q1["B"]
q1["C"] & r3 & gnd
vcc & q1["E"]
vcc & q2["E"]
# q1.xy = (1,1)
# q2.xy = (2,1)
# r1.xy = (0,0)
# r2.xy = (0,1)
# r3.xy = (1,2)
# r4.xy = (2,1)
# r5.xy = (2,2)
# vcct.xy = (2,0)
# gndt.xy = (1,2)
# gndt.fix = True
generate_svg()
def test_svg_5():
uc = Part(lib="MCU_STC", name="STC15W204S-35x-SOP16")
uc.split_pin_names("/")
uc.TxD_2.aliases += "UDM"
uc.RxD_2.aliases += "UDP"
usb = Part(lib="Connector", name="USB_B_Micro", symtx="H")
uc1 = uc()
uc1["UDM, UDP"] += usb["D-, D+"]
uc_spare = uc()
uc_spare["UDP"] & uc_spare["UDM"]
stubs = uc1["UDM"].get_nets()
stubs.extend(uc1["UDP"].get_nets())
for s in stubs:
s.stub = True
generate_svg()
def test_svg_6():
# q = Part(lib='Device.lib', name='Q_PNP_CBE', dest=TEMPLATE, symtx='V')
r = Part("Device", "R", dest=TEMPLATE)
gndt = Part("power", "GND")
vcct = Part("power", "VCC")
gnd = Net("GND")
vcc = Net("VCC")
(
gnd
& gndt
& r()
& r()
& (r(symtx="l") | r(symtx="R"))
& r()
& r()
& r()
& r()
& r()
& r()
& r()
& vcct
& vcc
)
generate_svg()
def test_svg_7():
u1 = Part("4xxx", "4001")
gnd = Net("GND")
u1.uA.VSS += gnd
u1.uA.VDD += gnd
gnd.stub = True
generate_svg(file_="test7")
def test_svg_8():
# Create nets.
e, b, c = Net("ENET"), Net("BNET"), Net("CNET")
e.stub, b.stub, c.stub = True, True, True
# Create part templates.
qt = Part(lib="Device", name="Q_PNP_CBE", dest=TEMPLATE)
# Instantiate parts.
for q, tx in zip(qt(8), ["", "H", "V", "R", "L", "VL", "HR", "LV"]):
q["E B C"] += e, b, c
q.ref = "Q_" + tx
q.symtx = tx
generate_svg()
def test_svg_9():
# Create part templates.
q = Part(lib="Device", name="Q_PNP_CBE", dest=TEMPLATE, symtx="V")
r = Part("Device", "R", dest=TEMPLATE)
# Create nets.
gnd, vcc = Net("GND"), Net("VCC")
# a, b, a_and_b = Net("A", netio="i"), Net("B", netio="i"), Net("A_AND_B", netio="o")
a, b, a_and_b = Net("A"), Net("B"), Net("A_AND_B")
# Instantiate parts.
gndt = Part("power", "GND") # Ground terminal.
vcct = Part("power", "VCC") # Power terminal.
q1, q2 = q(2)
r1, r2, r3, r4, r5 = r(5, value="10K")
# Make connections between parts.
a & r1 & q1["B", "C"] & r4 & q2["B", "C"] & a_and_b & r5 & gnd
b & r2 & q1["B"]
q1["C"] & r3 & gnd
vcc += q1["E"], q2["E"], vcct
gnd += gndt
a.netio = "i" # Input terminal.
b.netio = "i" # Input terminal.
a_and_b.netio = "o" # Output terminal.
q1.E.symio = "i" # Signal enters Q1 on E and B terminals.
q1.B.symio = "i"
q1.C.symio = "o" # Signal exits Q1 on C terminal.
q2.E.symio = "i" # Signal enters Q2 on E and B terminals.
q2.B.symio = "i"
q2.C.symio = "o" # Signal exits Q2 on C terminal.
q1.symtx = "L"
q2.symtx = "L"
vcc.stub = True
generate_svg()
def test_svg_10():
mosfet = Part("Device", "Q_PMOS_GSD")
mosfet.symtx = "HR"
mosfet.symtx = "HL"
pmos = Part("Device", "Q_PMOS_GSD")
n01 = Net("n01")
mosfet[1] += mosfet[2]
n01 += mosfet[3]
pmos[3] += mosfet[3]
generate_svg()
def test_svg_11():
return # This test is not working properly.
# vcc = Part("Device", "Battery", value=5 @ u_V)
# r1 = Part("Device", "R", value=1 @ u_kOhm)
# r2 = Part("Device", "R", value=2 @ u_kOhm)
vcc.convert_for_spice(V, {1: "p", 2: "n"})
r1.convert_for_spice(R, {1: "p", 2: "n"})
r2.convert_for_spice(R, {1: "p", 2: "n"})
vin, vout, gnd = Net("Vin"), Net("Vout"), Net("GND")
vin.netio = "i"
vout.netio = "o"
gnd.netio = "o"
gnd & vcc["n p"] & vin & r1 & vout & r2 & gnd
generate_svg()
def test_svg_12():
return # This test is not working properly.
@SubCircuit
def vga_port(red, grn, blu, hsync, vsync, gnd, logic_lvl=3.3):
"""Generate analog RGB VGA port driven by red, grn, blu digital color buses."""
# Determine the color depth by finding the max width of the digital color buses.
# (Note that the color buses don't have to be the same width.)
depth = max(len(red), len(grn), len(blu))
# Add extra bus lines to any bus that's smaller than the depth and
# connect these extra lines to the original LSB bit of the bus.
for bus in [red, grn, blu]:
add_width = depth - len(bus) # Number of lines to add to the bus.
if add_width > 0:
bus.insert(0, add_width) # Add lines to the beginning of the bus.
bus[add_width] += bus[
0:add_width
] # Connect the added bus lines to original LSB.
# Calculate the resistor weights to support the given color depth.
vga_input_impedance = 75.0 # Impedance of VGA analog inputs.
vga_analog_max = 0.7 # Maximum brightness color voltage.
# Compute the resistance of the upper leg of the voltage divider that will
# drop the logic_lvl to the vga_analog_max level if the lower leg has
# a resistance of vga_input_impedance.
R = (logic_lvl - vga_analog_max) * vga_input_impedance / vga_analog_max
# The basic weight is R * (1 + 1/2 + 1/4 + ... + 1/2**(width-1))
r = R * sum([1.0 / 2**n for n in range(depth)])
# The most significant color bit has a weight of r. The next bit has a weight
# of 2r. The next bit has a weight of 4r, and so on. The weights are arranged
# in decreasing order so the least significant weight is at the start of the list.
weights = [str(int(r * 2**n)) for n in reversed(range(depth))]
# Quad resistor packs are used to create weighted sums of the digital
# signals on the red, green and blue buses. (One resistor in each pack
# will not be used since there are only three colors.)
res_network = Part(
xess_lib, "RN4", footprint="xesscorp/xess.pretty:CTS_742C083", dest=TEMPLATE
)
# Create a list of resistor packs, one for each weight.
res = res_network(value=weights)
# Create the nets that will accept the weighted sums.
analog_red = Net("R")
analog_grn = Net("G")
analog_blu = Net("B")
# Match each resistor pack (least significant to most significant) with
# the the associated lines of each color bus (least significant to
# most significant) as follows:
# res[0], red[0], grn[0], blu[0]
# res[1], red[1], grn[1], blu[1]
# ...
# Then attach the individual resistors in each pack between
# a color bus line and the associated analog color net:
# red[0] --- (1)res[0](8) --- analog_red
# grn[0] --- (2)res[0](7) --- analog_grn
# blu[0] --- (3)res[0](6) --- analog_blu
# red[1] --- (1)res[1](8) --- analog_red
# grn[1] --- (2)res[1](7) --- analog_grn
# blu[1] --- (3)res[1](6) --- analog_blu
# ...
for w, r, g, b in zip(res, red, grn, blu):
w[1, 8] += r, analog_red # Red uses the 1st resistor in each pack.
w[2, 7] += g, analog_grn # Green uses the 2nd resistor in each pack.
w[3, 6] += b, analog_blu # Blue uses the 3rd resistor in each pack.
w[4, 5] += (
NC,
NC,
) # Attach the unused resistor in each pack to no-connect nets to suppress ERC warnings.
w[1].symio = "input"
w[8].symio = "output"
w[2].symio = "input"
w[7].symio = "output"
w[3].symio = "input"
w[6].symio = "output"
w[4].symio = "input"
w[5].symio = "output"
# VGA connector outputs the analog red, green and blue signals and the syncs.
vga_conn = Part(
"Connector",
"DB15_FEMALE_HighDensity_MountingHoles",
footprint="xesscorp/xess.pretty:DB15-3.08mm-HD-FEMALE",
)
vga_conn[5, 6, 7, 8, 9, 10] += gnd # Ground pins.
vga_conn[4, 11, 12, 15] += NC # Unconnected pins.
vga_conn[0] += gnd # Ground connector shield.
vga_conn[1] += analog_red # Analog red signal.
vga_conn[2] += analog_grn # Analog green signal.
vga_conn[3] += analog_blu # Analog blue signal.
vga_conn[13] += hsync # Horizontal sync.
vga_conn[14] += vsync # Vertical sync.
vga_conn[1].symio = "input"
vga_conn[2].symio = "input"
vga_conn[3].symio = "input"
vga_conn[13].symio = "input"
vga_conn[14].symio = "input"
# Define some nets and buses.
gnd = Net("GND") # Ground reference.
gnd.drive = POWER
# Five-bit digital buses carrying red, green, blue color values.
red = Bus("RED", 5)
grn = Bus("GRN", 5)
blu = Bus("BLU", 5)
# VGA horizontal and vertical sync signals.
hsync = Net("HSYNC")
vsync = Net("VSYNC")
xess_lib = r"/home/devb/tech_stuff/KiCad/libraries/xess.lib"
# Two PMOD headers and a breadboard header bring in the digital red, green,
# and blue buses along with the horizontal and vertical sync.
# (The PMOD and breadboard headers bring in the same signals. PMOD connectors
# are used when the VGA interface connects to a StickIt! motherboard, and the
# breadboard header is for attaching it to a breadboard.
pm = 2 * Part(
xess_lib, "PMOD-12", footprint="xesscorp/xess.pretty:PMOD-12-MALE", dest=TEMPLATE
)
pm[0].symtx = "H"
pm[1].symtx = "H"
bread_board_conn = Part(
"Connector",
"Conn_01x18_Male",
footprint="KiCad_V5/Connector_PinHeader_2.54mm.pretty:Pin_Header_1x18_P2.54mm_Vertical",
)
# Connect the digital red, green and blue buses and the sync signals to
# the pins of the PMOD and breadboard headers.
hsync += bread_board_conn[1], pm[0]["D0"]
vsync += bread_board_conn[2], pm[0]["D1"]
red[4] += bread_board_conn[3], pm[0]["D2"]
grn[4] += bread_board_conn[4], pm[0]["D3"]
blu[4] += bread_board_conn[5], pm[0]["D4"]
red[3] += bread_board_conn[6], pm[0]["D5"]
grn[3] += bread_board_conn[7], pm[0]["D6"]
blu[3] += bread_board_conn[8], pm[0]["D7"]
red[2] += bread_board_conn[9], pm[1]["D0"]
grn[2] += bread_board_conn[10], pm[1]["D1"]
blu[2] += bread_board_conn[11], pm[1]["D2"]
red[1] += bread_board_conn[12], pm[1]["D3"]
grn[1] += bread_board_conn[13], pm[1]["D4"]
blu[1] += bread_board_conn[14], pm[1]["D5"]
red[0] += bread_board_conn[15], pm[1]["D6"]
grn[0] += bread_board_conn[16], pm[1]["D7"]
blu[0] += bread_board_conn[17]
# The VGA interface has no active components, so don't connect the PMOD's VCC pins.
NC += pm[0]["VCC"], pm[1]["VCC"]
# Connect the ground reference pins on all the connectors.
gnd += bread_board_conn[18], pm[0]["GND"], pm[1]["GND"]
# The PMOD ground pins are defined as power outputs so there will be an error
# if they're connected together. Therefore, turn off the error checking on one
# of them to swallow the error.
pm[1]["GND"].do_erc = False
# Send the RGB buses and syncs to the VGA port circuit.
vga_port(red, grn, blu, hsync, vsync, gnd)
# Stub these nets.
gnd.stub = True
red.stub = True
grn.stub = True
blu.stub = True
hsync.stub = True
vsync.stub = True
ERC() # Run error checks.
generate_svg()
```
|
NWA Shockwave is a professional wrestling streaming television program produced by the National Wrestling Alliance (NWA). The show began airing on December 1, 2020 on NWA's YouTube channel. The series primarily featured matches taped during United Wrestling Network's weekly pay-per-view series, UWN Primetime Live.
List of episodes
References
External links
Official NWA YouTube channel
2020 American television series debuts
2020s American television series
National Wrestling Alliance shows
American professional wrestling television series
American non-fiction web series
English-language television shows
YouTube original programming
United Wrestling Network
|
The Powerstation is a music venue in Eden Terrace, Auckland, it is one of the few remaining small music venues in New Zealand.
History
First opened in the 1950s as a hotel lobby, The Powerstation soon become a "dine-and-dance" venue. In 1989, Galaxy started to host five bands for five dollars glam metal shows - sparking a renewed interest in the genre in Auckland.
In 1986, Simon Grigg, Roger Perry, and Tom Sampson opened the house music club 'Asylum' within the Galaxy venue. Whilst initially starting as a club playing hip hop, soul, and pop music, it soon gained a reputation for playing house music, making it the first house music club in Australasia. Grigg described Asylum as one of the first clubs that had no colour or race barriers, so the crowd came from south, west, north, east, and central Auckland and mostly happily mixed'.
By 2008, Galaxy had turned into an 80s-themed bar called Bar Retro. In 2009, Bar Retro went into receivership and Peter Campbell bought it and branded it as the Powerstation.
Notable Performances
The Pixies performed their first show in New Zealand in 2010 at The Powerstation.
Lorde's 2017 show had to be urgently rescheduled from The Powerstation to the Bruce Mason Centre as there were liquor-licensing issues for an all-ages gig.
In 2018, The Powerstation agreed to host - and then cancelled - an event hosted by far-right speakers Lauren Southern and Stefan Molyneux, generating controversy first for agreeing to host it, and then for cancelling it.
References
Music venues in New Zealand
Buildings and structures in Auckland
Waitematā Local Board Area
|
The Higher Law may refer to:
Higher Law Theory, arguing that no written law may be enforced unless it conforms with certain unwritten, universal principles of fairness, morality, and justice
The Higher Law (1911 film), directed by George Nichols
The Higher Law (1914 film), a lost film
|
Iran competed at the 1976 Winter Olympics in Innsbruck, Austria. Four athletes represented Iran in the 1976 Olympics, all of them in alpine skiing.
Competitors
Results by event
Skiing
Alpine
Men
References
External links
Official Olympic Reports
Nations at the 1976 Winter Olympics
1976
Winter Olympics
Pahlavi Iran
|
Henderson Airport may refer to:
Henderson Airport (Alabama), a former airport in Millers Ferry, Alabama, United States
Henderson Aviation Airport in Felton, Delaware, United States (FAA: 0N6)
Henderson City-County Airport in Henderson, Kentucky, United States (FAA: HNZ)
Henderson Executive Airport in Las Vegas, Nevada, United States (FAA: HND)
Henderson-Oxford Airport in Oxford, North Carolina, United States (FAA: HNZ)
See also
Honiara International Airport, Solomon Islands, locally referred to as Henderson Airport after the World War II airfield (FAA: HIR)
Rusk County Airport (Texas) in Henderson, Texas, United States (FAA: RFI)
Henderson Field (disambiguation)
|
James John Liautaud (born January 12, 1964) is an American restaurateur, who is widely known as the founder and former chairman of Jimmy John's sandwich chain.
In October 2018, Liautaud was included in the Forbes list of the world's wealthiest people. At this time, Forbes estimated Liautaud's documented wealth at $1.7 billion.
Family and early life
Liautaud was born in Arlington Heights, Illinois on January 12, 1964. His father is James Liautaud, longtime entrepreneur, and his mother is Gina Gudaityte Liautaud. He was born the second of four siblings, with brothers Greg and Robby Liautaud and a sister Lara Liautaud Berry. He attended high school at Elgin Academy, a private prep school in Elgin, Illinois, where he became close with and was influenced by the dean, James Lyons.
He studied at Eastern Illinois University, but left after one semester to grow his up-and-coming restaurant business.
Restaurant career
After Liautaud graduated from high school in 1982, his father offered him a loan of $25,000 to open a business on the condition that if the business failed, he would enlist in the US Army. Although his father wanted him to enlist, he agreed to loan the money in exchange for a 48% stake in the business. Initially Jimmy John wanted to open a hot dog stand, but after visiting numerous such stands throughout the summer of 1982, he realized the $25,000 would not be enough for such a venture. After a chance encounter at a sandwich shop, Jimmy John realized that he could open a sandwich shop within his available budget by purchasing premium meats at a neighborhood market and baking his own bread. With the help of his family as tasters, he decided to put four sandwiches on his original menu. On January 13, 1983 Jimmy John's Gourmet Sandwiches opened in Charleston, Illinois. Due to the poor location of his first store, Liautaud decided to include delivery of his sandwiches to boost sales. He began by bringing samples door-to-door to the nearby Eastern Illinois University dorms. By the end of his first year, the restaurant started making a profit. At the end of his second year, Liautaud was able to purchase his father's share in the business and he became sole owner. The business continued to grow, and he was able to open his second and third shops in 1986 and 1987.
In 1988, Liautaud met businessman Jamie Coulter. At the time, Coulter was a Pizza Hut Franchisee, and later founded and ran Lone Star Steakhouse and Saloon and other chains. Coulter helped Liautaud take his business to the next level. In 1994 he sold his first Jimmy John's franchise, in addition to the 10 stores owned by Liautaud himself.
By 2002, the company had about 200 stores, 10% of which were corporate stores that Liautaud oversaw himself. Sales at the stores managed by Liautaud were outpacing the franchised stores by a wide margin. Together with his partner, and now President & CEO, James North, he visited 70 of the poorest-performing stores. After 18 months of getting the stores “back to basics” and instilling in them “some of that initial spark”, he was able to help the stores become more profitable.
In January 2007, Liautaud selected Weston Presidio, a private-equity firm, to help acquire better locations for the expanding company. Weston Presidio bought a 33% stake in the company, and during the first year closed on over 100 real estate deals.
In September 2016, Roark Capital Group agreed to purchase a majority stake in Liautaud's company, as Weston Presidio sold their minority investment after 10 years. Terms of the transaction were not immediately disclosed, though it was later clarified that Liautaud retained 35% ownership of the company as part of the deal. As part of the agreement, Liautaud, as the company's founder and largest individual shareholder, continued as chairman of the board.
In his 2018 book, Dick Portillo of Portillo's Restaurants called Liautaud his "good friend" and relayed that Liautaud tried to buy Portillo's before it was ultimately sold to Berkshire Partners.
In September 2019, Roark's Inspire Brands announced it was acquiring Jimmy John's for an unspecified amount in a deal unanimously approved by Liautaud and the rest of the Jimmy John's Board of Directors. At the close of the deal, Liautaud said that he will step down as chairman of the company and transition to become an advisor to the brand. The acquisition was completed on October 18.
Philanthropy
In 2008, Liautaud donated $1 million to his high school, Elgin Academy, on the condition that the building constructed using his donation bear not only his name, but also the name of the man who had been the dean of the school when Liautaud attended: James Lyons.
In 2011, Liautaud and his wife pledged $1 million toward the construction of the new Champaign County YMCA.
In July 2014, Liautaud donated $1 million to the Folds of Honor Foundation, an organization that supports the spouses and children of America's fallen and disabled service-members.
In 2017, Liautaud and his wife, Leslie, donated $2 million to help Brewster Academy kick off the fundraising for their new residence hall to house 22 students and 4 faculty residences. In May 2018, the new residence opened, and is called "Toad Hall" after a common mispronunciation of the family's last name.
In January 2019, Camp Southern Ground, a non-profit summer camp founded by musician Zac Brown, announced that the Liautauds had donated over $3.2 million to date to help build the camp's first residential lodge and fund ongoing operations. In non-summer months, the camp's facilities are used to support military veterans and their families transitioning back to civilian life.
The Liautaud Family Foundation directed $1.291 million to the Horatio Alger Association to support scholarships for underprivileged students in 2019.
Liautaud partnered with his father to create with an endowment gift of $5 million, the Liautaud Graduate School of Business at the University of Illinois-Chicago.
The Liautauds donated $1 million to Chicago's Youth Guidance Becoming a Man program, which helps disadvantaged young men learn how to handle tough life challenges and give them the tools to succeed in the future.
Other causes supported by the Liautauds include: the Frances Nelson Smile Healthy Dental Clinic, the Kickapoo Rail Trail, Crisis Nursery in Urbana, Illinois, Champaign County's Youth Assessment Center, Champaign Unit 4 schools, Christmas layaway purchases, the American Heart Association, the Mayo Clinic Center for Individualized Medicine, MD Anderson, the Pancreatic Cancer Action Network, the Lurie Children's Hospital of Chicago, the Goodman Theater, and the Detroit Symphony.
Honors
Liautaud is a member of the University of Illinois at Chicago's Chicago Area Entrepreneurship Hall of Fame.
In 2003, he was named to Chicago's “40 Under 40” by Crain's Chicago Business.
In 2004, he was named the Ernst & Young Food & Beverage Entrepreneur of the Year in Illinois. The winners were selected by an independent panel of judges composed of local community and business leaders. In the same year, he was given the Lifetime Achievement Award at the National CEO Conference and inducted into the Collegiate Entrepreneurs' Organization Hall of Fame.
In 2007, Liautaud delivered the commencement speech at his alma mater, now known as the Liautaud-Lyons Upper School, a program of Elgin Academy.
In 2012, Liautaud was awarded the Nation's Restaurant News Golden Chain award for outstanding accomplishments that have benefited consumers in the food industry.
In March 2017, he was named Franchise Times' "Dealmaker of the Year" for the deal that brought Roark Capital Group in as the company's new majority owner. Beth Ewen, FT's editor-in-chief called the deal "one of the best private equity deals of all time in the restaurant business." In December of that year, Liautaud was chosen to receive the Horatio Alger Award for 2018. The Horatio Alger Association of Distinguished Americans recognizes people who have overcome personal challenges to achieve personal and professional success.
Public speaking
Liautaud has spoken at high schools; colleges and universities; and community spaces.
Hunting
Liautaud is an avid hunter and fisherman. In an interview in 2015 with the Chicago Tribune, Liautaud said that the largest misconception about him is that people still connect him to photos of him posing with big game from 10 years ago. According to Liautaud, he used to hunt big game in Africa on legally organized safaris, but he no longer does. Starting in 2015, his hunting prompted people to call for a boycott of his business.
Personal life
Liautaud is married to Leslie Liautaud and has three children, Spencer, Lucy, and Fred. Liautaud is an investor in wines and vineyards, at least one of which has been featured on the cover of Wine Spectator. He also owns thousands of acres of farmland in Central Illinois.
Liautaud also owns a superyacht named ROCK.IT, a 198-foot ship built with his input by Feadship in 2014. The ship, which can accommodate ten guests with a crew of 13, has been a finalist for a few yacht awards and been featured in a number of industry publications.
References
External links
Jimmy John Liautaud's official website
1964 births
20th-century American businesspeople
21st-century American businesspeople
Businesspeople from Illinois
American people of Lithuanian descent
Eastern Illinois University alumni
Living people
People from Arlington Heights, Illinois
|
The Kinston Expos were a Minor League Baseball team of the Carolina League (CL), and the High-A affiliate of the Montreal Expos. They were located in Kinston, North Carolina, and were named for their parent club. The team played its home games at Grainger Stadium, which opened in 1949 and holds 4,100 fans.
Established in 1962, the Expos played through the 1974 season. The franchise folded following that season.
Kinston has served as a farm club for eleven different major league franchises and one minor league club. Professional baseball dates back to a 1908 squad in the Eastern Carolina League. Despite having one of the smallest markets in professional baseball, Kinston has proved its viability for over a century.
The franchise won a league title as the Kinston Eagles in 1962 as an affiliate of the Pittsburgh Pirates. Hundreds of men played for the franchise including Ron Guidry.
Kinston is served today by the Down East Wood Ducks, an affiliate of the Texas Rangers.
History
Kinston's re-entry into Carolina League baseball in was successful both on the field and at the turnstile. The Eagles were able to claim the first of its Carolina League crowns. At a time when Kinston's population was only 25,000, the ball club attracted over 140,000 fans. Part of the lure was the talent supplied by Kinston's parent club, the Pittsburgh Pirates, which included Steve Blass (17–3, 1.97 ERA, 209 K's), and Frank Bork (19–7, 2.00 ERA). Another fan attraction was that the Eagles were for the first time a community owned team, operating under the non-profit Kinston Eagles Baseball Company, run by an elected eighteen-man, unpaid board of directors. Profits were reinvested into improving the stadium, promoting the team, and supplying playing equipment for the youth of Kinston. This arrangement continued through all thirteen years of Kinston's second tenure in the Carolina League, from through .
In minor league baseball was restructured nationwide, with B, C and D classes eliminated. The Carolina League became a High-A circuit. The Eagles failed to win any championships during this second era of Carolina League play, but they managed to make the playoffs in six of thirteen seasons. The Pirates stuck with Kinston through the campaign. During three of those four seasons, the Eagles were managed by Harding "Pete" Peterson, who later oversaw the Pirates farm system, and become the Pirates' general manager, helping to build the late seventies team that won the World Series. The Eagles became affiliated with the new Atlanta Braves during and , under the management of Andy Pafko. From through the Eagles were affiliation with the New York Yankees; the fans saw a lot of future all-stars pass through the city including a young Ron Guidry who would soon establish himself as one of the best pitchers in the American League.
During the 1970s the popularity of minor league baseball reached its lowest point and the attendance in Kinston fell to only 30,000 for the season. The city needed a revival of interest, and the Expos were turned to for help. The young Montreal franchise boasted a strong farm system with a lot of talent. So much talent in fact, that they decided to experiment with having two High A affiliates. Instead of dividing the players evenly between the two, all the top players were placed in the West Palm Beach club, while the newly renamed Kinston Expos had to make do with castoffs. The Kinston team soon found itself overmatched among its Carolina League rivals. The Expos fell to last place and attendance fell to only 27,000 for the year. Montreal declared the experiment a failure and withdrew from Kinston following the season. With no major league sponsor and very little fan support, Kinston likewise withdrew from the league.
Grainger Stadium
The Kinston Expos, and all the Kinston teams since 1949, played their home games at Grainger Stadium located at 400 East Grainger Avenue in Kinston. The original structure was built by architect John J. Rowland in 1949 at a cost of $170,000 inclusive of everything except the land. $150,000 of the money was raised by bond issue. The stadium is owned by the city and leased by the team. A dedicatory plaque identifies the structure as "Municipal Stadium", but it has been called Grainger Stadium since it was first built. The name Grainger comes from its location on Grainger Avenue as well as its use early on by Grainger High School. Grainger is a prominent old family name in Lenoir County.
Season by season results
TABLE NOTES:
Sources
No Hitters
Conrad Noessel (6/11/1966) vs the Tidewater Tides (7 innings)
William Olsen (5/11/1970) vs the Burlington Senators
Bob Elliott (6/14/1970) vs the Lynchburg Twins (7 innings)
See also
Grainger Stadium
Carolina League
Bibliography
Autobiographies and biographies
League histories
Newspapers
– Issues for all seasons are available on microfilm at Lenoir Community College.
Official sources
– Programs are also referred to as yearbooks.
– Over the years, this publication has also been known as Carolina League Media Guide and Record Book and Carolina League Directory and Record Book
Footnotes
Baseball teams established in 1962
Lenoir County, North Carolina
Professional baseball teams in North Carolina
Montreal Expos minor league affiliates
New York Yankees minor league affiliates
Atlanta Braves minor league affiliates
Pittsburgh Pirates minor league affiliates
Sports clubs and teams disestablished in 1974
1962 establishments in North Carolina
1974 disestablishments in North Carolina
Defunct baseball teams in North Carolina
Baseball teams disestablished in 1974
|
```xml
import * as angular from 'angular';
import adal = require('adal-angular');
import { IWebAPIServce } from '../webApiService';
import { IGraphApi } from '../../models/IGraphApi';
export class ElevatedPrivilegesController {
public static $inject: string[] = ['$scope', '$log', 'WebAPIService', 'adalAuthenticationService'];
// public variables
public displayName: string;
public signedIn: boolean = false;
public user: IGraphApi;
// private variables
private _hasGraphToken: boolean = false;
private _hasAPIToken: boolean = false;
constructor(private $scope: angular.IScope, private $log: angular.ILogService,
private $api: IWebAPIServce, private $adalProvider: adal.AdalAuthenticationService) {
if (this.hasGraphToken()) {
this.callGraph();
}
}
public signOn(): void {
this.$adalProvider.login();
}
public signOut(): void {
this.$adalProvider.logOut();
}
public isAuthenticated(): boolean {
return this.$adalProvider.userInfo.isAuthenticated;
}
public getGraphToken(): void {
this.$adalProvider.acquireToken("path_to_url");
}
public getAPIToken(): void {
this.$adalProvider.acquireToken('path_to_url
}
public hasGraphToken(): boolean {
this._hasGraphToken = this.$adalProvider.getCachedToken("path_to_url") !== null;
return this._hasGraphToken;
}
public hasAPIToken(): boolean {
this._hasAPIToken = this.$adalProvider.getCachedToken('path_to_url !== null;
return this._hasAPIToken;
}
public callGraph(): void {
this.$api.getMe()
.then((result: any): void => {
this.$log.debug("success call to graph api");
this.user = result.data;
});
}
public callApi(): void {
this.$api.getItem()
.then((result: any): void => {
this.$log.debug("success call to web api");
this.$log.debug(result);
alert('success call to custom web api');
});
}
}
```
|
The 1998–99 Siena Saints men's basketball team represented Siena College in the 1998–99 college basketball season. This was head coach Paul Hewitt's second season at Siena. The Saints competed in the Metro Atlantic Athletic Conference (MAAC) and played their home games at Pepsi Arena in Albany, New York. They finished the season 25–6, 13–5 in MAAC play to end up second in the regular season standings. They won the 1999 MAAC men's basketball tournament to earn the conference's automatic bid to the 1999 NCAA Division I men's basketball tournament. The Saints received the 13 seed in the West region where they were defeated by No. 4 seed Arkansas in the opening round.
Roster
Source
Schedule and results
All times are Eastern
|-
!colspan=9 style=| Regular Season
|-
!colspan=10 style=| MAAC tournament
|-
!colspan=10 style=| NCAA tournament
Source
References
Siena
Siena Saints men's basketball seasons
Siena
Siena Saints men's basketball
Siena Saints men's basketball
|
```xml
import { IAppDocument } from '../../db/models/definitions/apps';
import { IContext } from '../../connectionResolver';
export default {
async userGroupName(app: IAppDocument, _args, { models }: IContext) {
const group = await models.UsersGroups.findOne({ _id: app.userGroupId });
return group ? group.name : 'Allowed for all users';
}
};
```
|
Wheeleria spilodactylus (the horehound plume moth) is a moth of the family Pterophoridae, first described by John Curtis in 1827. It is found in South-Western and Central Europe and the Mediterranean, Asia Minor and North Africa. It has been introduced to Australia as a biocontrol agent for white horehound (Marrubium vulgare).
The wingspan is . Adults are on wing from July to September depending on the location.
The difficult to see larvae feed on black horehound (Ballota nigra) and white horehound.
References
External links
Species info
Pterophorini
Moths described in 1827
Moths of Australia
Moths of North America
Plume moths of Asia
Plume moths of Africa
Plume moths of Europe
Moths of Asia
Taxa named by John Curtis
|
The Ground Master 400 is a mobile long range radar system manufactured by Thales (formerly by Thales-Raytheon Systems). GM400 is a fully digital active electronically scanned array long-range air defense 3D radar, offering detection from very high to very low altitudes. It tracks a wide range of targets from highly maneuverable tactical aircraft flying below several hundred feet to the unconventional small radar cross section devices, such as UAVs or cruise missiles.
The system can be set up by a four-man crew in 60 minutes and can be remotely operated. The system fits in a 20-feet shipping container and weighs less than ten tons. The system can be rapidly deployed mounted on a 6x6 or 8x8 tactical truck and can be transported by a single C-130 aircraft or a helicopter.
The GM400 with a field-proven operational availability of more than 98,5% and a MTBCF of 3500 hrs has been selected by many countries as well as France to protect the European Space Agency's Guiana Space Centre. The system was to be operational by the end of 2012.
The GM400 family includes the GM403 and the GM406. The GM406 has a transmitter which is twice as powerful as the GM403, giving it 20% greater range, increasing from 390 km to 450 km. The GM406 is primarily designed to equip fixed sites, with the GM403 designed to be deployable.
In 2021, Thales introduced a new version, GM400α, with 5 times more processing power, extended range from 470 to 515 km and upcoming advanced artificial intelligence algorithms.
These systems are part of the Ground Master family of radars (alongside the medium range GM200 and GM200 MM/A and MM/C as well as the short-range GM60 and its variants) and have been purchased by many countries.
Main characteristics
Air Surveillance Radar
Crew: 4
S-band, 3D AESA Radar
GaN technology
Modern algorithm to mitigate windfarm effect
10 RPM Rotation Rate
High, medium and low-altitude detection, long-range air defense sensor
Detects fixed- and rotary-wing aircraft, cruise missiles, UAVs, and tactical ballistic missiles
Coverage:
Azimuth: 360°
Elevation: 20° and 40°
Performance:
Detection range:
Fighter aircraft: > 450 km
Cruise missile: > 250 km
Max detection rate in altitude: 30.5 km
Instrumented range: 515 km
High mobility, transportability, and reliability
GM400 requires minimum maintenance (30 hours/year)
Technical characteristics:
Digital Beam Forming
Stacked beam (maximum time on target) technology
S-Band (high part 2.9 / 3.3 GHz)
Clear & Doppler modes
Electronic Counter-CounterMeasures (ECCM) capabilities
Tactical ballistic missile (TBM) detection capability.
Operators
: 2 systems
: 4 systems
: 9 systems
: 2 Ground Master 403 systems, 2 more Ground Master 400 Alpha systems ordered in June 2023.
: 12 Ground Master 403 systems. Local designation is Keva 2010.
: 3 GM 406 systems and 12 GM 403 systems
: 6 GM 403 and GM 200 systems
: 6 systems
: 13 GM400α systems
: 9 systems
: 2 systems in service, 1 more on order.
: 3 systems
: 2 systems
: 2 systems on order, delivery in 2023
: 2 Ground Master 403 systems.
See also
KALKAN Air Defence Radar
TAFLIR, another ground-based, non-fixed (i.e., transportable) search radar (AN/TPS)
AN/TPS-43
AN/TPS-75
External links
Ground Master 400 Alpha - Thales Group
References
Ground radars
Military radars of France
Thales Group
|
```c
/*
*
* in the file LICENSE in the source distribution or at
* path_to_url
*/
#include "e_os.h"
#include "internal/err.h"
#include <openssl/crypto.h>
#include <openssl/evp.h>
#include <openssl/conf.h>
#include <assert.h>
#include "ssl_locl.h"
#include "internal/thread_once.h"
static int stopped;
static void ssl_library_stop(void);
static CRYPTO_ONCE ssl_base = CRYPTO_ONCE_STATIC_INIT;
static int ssl_base_inited = 0;
DEFINE_RUN_ONCE_STATIC(ossl_init_ssl_base)
{
#ifdef OPENSSL_INIT_DEBUG
fprintf(stderr, "OPENSSL_INIT: ossl_init_ssl_base: "
"Adding SSL ciphers and digests\n");
#endif
#ifndef OPENSSL_NO_DES
EVP_add_cipher(EVP_des_cbc());
EVP_add_cipher(EVP_des_ede3_cbc());
#endif
#ifndef OPENSSL_NO_IDEA
EVP_add_cipher(EVP_idea_cbc());
#endif
#ifndef OPENSSL_NO_RC4
EVP_add_cipher(EVP_rc4());
# ifndef OPENSSL_NO_MD5
EVP_add_cipher(EVP_rc4_hmac_md5());
# endif
#endif
#ifndef OPENSSL_NO_RC2
EVP_add_cipher(EVP_rc2_cbc());
/*
* Not actually used for SSL/TLS but this makes PKCS#12 work if an
* application only calls SSL_library_init().
*/
EVP_add_cipher(EVP_rc2_40_cbc());
#endif
EVP_add_cipher(EVP_aes_128_cbc());
EVP_add_cipher(EVP_aes_192_cbc());
EVP_add_cipher(EVP_aes_256_cbc());
EVP_add_cipher(EVP_aes_128_gcm());
EVP_add_cipher(EVP_aes_256_gcm());
EVP_add_cipher(EVP_aes_128_ccm());
EVP_add_cipher(EVP_aes_256_ccm());
EVP_add_cipher(EVP_aes_128_cbc_hmac_sha1());
EVP_add_cipher(EVP_aes_256_cbc_hmac_sha1());
EVP_add_cipher(EVP_aes_128_cbc_hmac_sha256());
EVP_add_cipher(EVP_aes_256_cbc_hmac_sha256());
#ifndef OPENSSL_NO_CAMELLIA
EVP_add_cipher(EVP_camellia_128_cbc());
EVP_add_cipher(EVP_camellia_256_cbc());
#endif
#if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
EVP_add_cipher(EVP_chacha20_poly1305());
#endif
#ifndef OPENSSL_NO_SEED
EVP_add_cipher(EVP_seed_cbc());
#endif
#ifndef OPENSSL_NO_MD5
EVP_add_digest(EVP_md5());
EVP_add_digest_alias(SN_md5, "ssl3-md5");
EVP_add_digest(EVP_md5_sha1());
#endif
EVP_add_digest(EVP_sha1()); /* RSA with sha1 */
EVP_add_digest_alias(SN_sha1, "ssl3-sha1");
EVP_add_digest_alias(SN_sha1WithRSAEncryption, SN_sha1WithRSA);
EVP_add_digest(EVP_sha224());
EVP_add_digest(EVP_sha256());
EVP_add_digest(EVP_sha384());
EVP_add_digest(EVP_sha512());
#ifndef OPENSSL_NO_COMP
# ifdef OPENSSL_INIT_DEBUG
fprintf(stderr, "OPENSSL_INIT: ossl_init_ssl_base: "
"SSL_COMP_get_compression_methods()\n");
# endif
/*
* This will initialise the built-in compression algorithms. The value
* returned is a STACK_OF(SSL_COMP), but that can be discarded safely
*/
SSL_COMP_get_compression_methods();
#endif
/* initialize cipher/digest methods table */
ssl_load_ciphers();
#ifdef OPENSSL_INIT_DEBUG
fprintf(stderr, "OPENSSL_INIT: ossl_init_ssl_base: "
"SSL_add_ssl_module()\n");
#endif
SSL_add_ssl_module();
/*
* We ignore an error return here. Not much we can do - but not that bad
* either. We can still safely continue.
*/
OPENSSL_atexit(ssl_library_stop);
ssl_base_inited = 1;
return 1;
}
static CRYPTO_ONCE ssl_strings = CRYPTO_ONCE_STATIC_INIT;
static int ssl_strings_inited = 0;
DEFINE_RUN_ONCE_STATIC(ossl_init_load_ssl_strings)
{
/*
* OPENSSL_NO_AUTOERRINIT is provided here to prevent at compile time
* pulling in all the error strings during static linking
*/
#if !defined(OPENSSL_NO_ERR) && !defined(OPENSSL_NO_AUTOERRINIT)
# ifdef OPENSSL_INIT_DEBUG
fprintf(stderr, "OPENSSL_INIT: ossl_init_load_ssl_strings: "
"ERR_load_SSL_strings()\n");
# endif
ERR_load_SSL_strings();
ssl_strings_inited = 1;
#endif
return 1;
}
DEFINE_RUN_ONCE_STATIC(ossl_init_no_load_ssl_strings)
{
/* Do nothing in this case */
return 1;
}
static void ssl_library_stop(void)
{
/* Might be explicitly called and also by atexit */
if (stopped)
return;
stopped = 1;
if (ssl_base_inited) {
#ifndef OPENSSL_NO_COMP
# ifdef OPENSSL_INIT_DEBUG
fprintf(stderr, "OPENSSL_INIT: ssl_library_stop: "
"ssl_comp_free_compression_methods_int()\n");
# endif
ssl_comp_free_compression_methods_int();
#endif
}
if (ssl_strings_inited) {
#ifdef OPENSSL_INIT_DEBUG
fprintf(stderr, "OPENSSL_INIT: ssl_library_stop: "
"err_free_strings_int()\n");
#endif
/*
* If both crypto and ssl error strings are inited we will end up
* calling err_free_strings_int() twice - but that's ok. The second
* time will be a no-op. It's easier to do that than to try and track
* between the two libraries whether they have both been inited.
*/
err_free_strings_int();
}
}
/*
* If this function is called with a non NULL settings value then it must be
* called prior to any threads making calls to any OpenSSL functions,
* i.e. passing a non-null settings value is assumed to be single-threaded.
*/
int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS * settings)
{
static int stoperrset = 0;
if (stopped) {
if (!stoperrset) {
/*
* We only ever set this once to avoid getting into an infinite
* loop where the error system keeps trying to init and fails so
* sets an error etc
*/
stoperrset = 1;
SSLerr(SSL_F_OPENSSL_INIT_SSL, ERR_R_INIT_FAIL);
}
return 0;
}
if (!OPENSSL_init_crypto(opts
| OPENSSL_INIT_ADD_ALL_CIPHERS
| OPENSSL_INIT_ADD_ALL_DIGESTS,
settings))
return 0;
if (!RUN_ONCE(&ssl_base, ossl_init_ssl_base))
return 0;
if ((opts & OPENSSL_INIT_NO_LOAD_SSL_STRINGS)
&& !RUN_ONCE(&ssl_strings, ossl_init_no_load_ssl_strings))
return 0;
if ((opts & OPENSSL_INIT_LOAD_SSL_STRINGS)
&& !RUN_ONCE(&ssl_strings, ossl_init_load_ssl_strings))
return 0;
return 1;
}
```
|
```javascript
// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: path_to_url
(function(mod) {
if (typeof exports == "object" && typeof module == "object") // CommonJS
mod(require("../../lib/codemirror"));
else if (typeof define == "function" && define.amd) // AMD
define(["../../lib/codemirror"], mod);
else // Plain browser env
mod(CodeMirror);
})(function(CodeMirror) {
"use strict";
// Depends on js-yaml.js from path_to_url
// declare global: jsyaml
CodeMirror.registerHelper("lint", "yaml", function(text) {
var found = [];
try { jsyaml.load(text); }
catch(e) {
var loc = e.mark;
found.push({ from: CodeMirror.Pos(loc.line, loc.column), to: CodeMirror.Pos(loc.line, loc.column), message: e.message });
}
return found;
});
});
```
|
Olfactory receptor 1L6 is a protein that in humans is encoded by the OR1L6 gene.
Olfactory receptors interact with odorant molecules in the nose, to initiate a neuronal response that triggers the perception of a smell. The olfactory receptor proteins are members of a large family of G-protein-coupled receptors (GPCR) arising from single coding-exon genes. Olfactory receptors share a 7-transmembrane domain structure with many neurotransmitter and hormone receptors and are responsible for the recognition and G protein-mediated transduction of odorant signals. The olfactory receptor gene family is the largest in the genome. The nomenclature assigned to the olfactory receptor genes and proteins for this organism is independent of other organisms.
See also
Olfactory receptor
References
Further reading
External links
Olfactory receptors
|
Ebor (1814–1822) was a British Thoroughbred racehorse and sire best known for winning the classic St Leger Stakes in 1817. Bred, trained and raced in Yorkshire, Ebor was lightly campaigned, running only six times in a three-year racing career which was confined to the meetings at York and Doncaster. He won four times, one of these being a walkover. His St Leger win (his only important success) saw him upset the favourite Blacklock in a dramatic and controversial finish. After his retirement he became a breeding stallion but died before he could make an impact at stud.
Background
Ebor was a bay horse with a white star and one white foot bred at Bedale in Yorkshire by Henry Peirse in whose white and straw colours he competed during his racing career. Ebor was sired by the 1799 St Leger winner Orville, a successful staying racehorse who excelled over extreme distances. At stud he was Champion sire in 1817 and 1822 and sired the Classic winners Octavius (Derby Stakes), Emilius (Derby), Charlotte (1000 Guineas) and Zoe (1000 Guineas). Ebor's dam Constantia, regarded as the foundation mare of Thoroughbred family 19-b had previously produced Lisette, the dam of the 2000 Guineas winner Clearwell. Another of Lisette's foals, Madame Vestris, was the female ancestor of many important winners throughout the nineteenth and twentieth centuries.
Racing career
1817: three-year-old season
Ebor did not race as a two-year-old, beginning his racing career at York Racecourse on 22 May 1817. He started at odds of 3/1 and finished third of the six runner's behind Christopher Wilson's colt Parlington and Richard Gascoigne's unnamed brown colt.
Ebor did not race again until 22 September, when he was one of eighteen colts and fillies to contest the forty-second running of the St Leger Stakes at Doncaster Racecourse. The strong favourite for the race was Richard Watt's unnamed Whitelock colt (later named Blacklock) who started at odds of 4/5, despite having his first run of the season. Ebor, ridden by Robert Johnson, was a 20/1 outsider. The Whitelock colt, ridden with great confidence by John Jackson, took the lead in the straight and seemed poised to win very easily. In the closing stages, Jackson, who had boasted that he would win the race in a canter, began to ease the favourite down, apparently unaware that Bob Johnson was delivering a strong challenge on Ebor along the rail. By the time Jackson was alerted to the danger by the shouts of the crowd it was too late, and Ebor repelled the favourite's renewed challenge to win by a neck, with Restless in third place. Although there was a great deal of ill-feeling directed at Jackson, it was generally acknowledged that the favourite's defeat was a result of overconfidence rather than dishonesty.
A year later, the Sporting Magazine recalled the contest for the St Leger as an "admirable race" but reported that Blacklock was almost universally regarded as the better horse and stated that his defeat had been due to "the inattention of his rider".
1818: four-year-old season
As a four-year-old, Ebor was unbeaten in three races, although he was not tested at the highest level. He did not appear until the York August meeting where he had two engagements, the first in a four-mile Produce Sweepstakes for four-year-old colts and fillies. The betting suggested that he was his owner's second string, as the favourite was Henry Peirse's grey filly by Orville out of Ebor's half-sister Lisette. The filly's chance ended when she fell at the start, and Ebor won the race from Donna Rodriguez, the only other runner. Three days later, Ebor started at odds of 1/3 for a two-mile Sweepstakes at the same course, and won from Lord Fitzwilliam's colt Anselmo. Ebor returned to Doncaster in September for his only other appearance of the season. His owner was able to claim the prize in a four-mile sweepstakes without having to race his colt, as the other four entries were withdrawn, allowing Ebor to walk over.
1819: five-year-old season
Before being retired to stud, Ebor made one appearance as a five-year-old in 1819. He ran for the third consecutive year at Doncaster's St Leger meeting in September, contesting the weight-for-age Fitzwilliam Stakes over one and a half miles. He finished second of the eight runners behind Mr Fox's four-year-old Merlin, the 1/2 favourite.
Stud career
Ebor began his breeding career at Peirse's Snape Hall stud near Bedale, where he stood at a fee of 10 guineas a mare, with a guinea for the groom. He had little chance to prove himself as a sire, dying from an "inflammation of the bowels" on 4 April 1822 at the age of eight.
Pedigree
Ebor was inbred 3 × 3 to Highflyer, meaning that this stallion appears twice in the third generation of his pedigree. He was also inbred 4 × 4 × 4 × 4 to Highflyer's sire Herod.
References
1814 racehorse births
1822 racehorse deaths
Racehorses bred in the United Kingdom
Racehorses trained in the United Kingdom
Thoroughbred family 19-b
St Leger winners
|
Castabala may refer to :
Castabala (city), or Hierapolis (ad Pyram), in modern Turkey, an Ancient former city and bishopric in Cilicia, presently a Latin Catholic titular bishopric
Castabala, a genus of insects currently considered synonymous with Barsine
|
Francis K. Lelo is a Kenyan academic, researcher and academic administrator. He is an associate professor of Environmental Studies at Egerton University. He has also served as the vice chancellor Laikipia University and as ag. Prior to that, he was a principal at Kisii University College (South-Western Kenya). Francis K. Lelo is an expert in community mobilization and is well known for his efforts in environmental conservation.
Career
Lelo has a longstanding relationship with Clark University that began in 1981, when he was recruited as a research assistant by Richard Ford, a Clark professor who was engaged in a special project for USAID. Additionally, Lelo obtained a master's degree in environmental science from York University in Toronto. In 1990, he was awarded a scholarship to pursue his doctorate in geography at Clark and spent four years in Worcester. Lelo also served as the coordinator for Kenya's Participatory Rural Appraisal, a program created by Ford and fellow Clark professor Barbara Thomas-Slayter to equip African villages with the necessary tools and strategies to enhance their quality of life, ranging from developing a sustainable local economy to resolving internal conflicts. In 2008, he became part of Laikipia University College (later renamed Laikipia University), where he progressed to the position of vice chancellor in 2013. Clark University presented Vice Chancellor Lelo with an honorary degree.
References
1952 births
Living people
Academic staff of Egerton University
York University alumni
University of Nairobi alumni
Clark University alumni
Kenyan conservationists
Academic staff of Laikipia University
|
Joan Eileen Walsh (1932–2017) was a British mathematician, a professor of numerical analysis at the University of Manchester, and the founding chair of the Numerical Algorithms Group. She was the first female professor of mathematics in the UK.
Education
Walsh was born on 7 October 1932.
She read mathematics at the University of Oxford, where she earned a bachelor's degree with first class honours in 1954.
She became a teacher and assistant mistress at Howell's School, Denbigh,
but left after three years to study numerical analysis at the University of Cambridge. She earned a diploma (with distinction) from Cambridge in 1958, and returned to Oxford for her doctoral studies. There, she became the first student of Leslie Fox, completing her D.Phil. in 1961. She was also the first student to obtain a doctorate from the Oxford Computing Laboratory, the predecessor to the Department of Computer Science, University of Oxford.
Career
After working as a mathematical programmer for the Central Electricity Generating Board,
Walsh joined the mathematics staff at the University of Manchester in 1963. In 1974 she became the first female Professor of Mathematics in the UK when she was appointed as Professor of Numerical Analysis there in 1974. She was head of the mathematics department at Manchester from 1986 to 1989, and in 1990 became pro-vice-chancellor of the university. She retired to become a professor emeritus in 1998.
Walsh was one of the four founders of the Nottingham Algorithms Group in 1970, along with Brian Ford who was a Lecturer at the University of Nottingham; Shirley Lill, Lecturer in Optimization at the University of Leeds; and Linda Hayes, who was the research assistant of Professor Leslie Fox. The Nottingham Algorithms Group subsequently became the Numerical Algorithms Group Ltd. and Walsh became founding chair in 1976. Software libraries such as the NAG library are now seen as essential to the work of all computational scientists. Walsh is considered to be a pioneer in the field of computing as it developed in the second half of the 20th Century.
Research
Walsh conducted research into the numerical solution of ordinary differential equation boundary value problems and partial differential equations. She carried out a large part of her research in collaboration with PhD students.
Recognition
Fellow of the Institute of Mathematics and its Applications (from 1984). Vice-President of the Institute of Mathematics and its Applications (1992-1993).
President of the National Conference of University Professors (1993–1994).
NAG Life Service Recognition Award (2011)
Personal life
Joan was a devout Catholic and when she retired she completed an MA in Contemporary Theology in the Catholic Tradition at Heythrop College, University of London. She also successfully campaigned for the restoration of the Tridentine Latin Mass to the liturgy of the world-wide church.
She died on 30 December 2017.
References
1932 births
2017 deaths
British mathematicians
Women mathematicians
Numerical analysts
Alumni of the University of Oxford
Alumni of the University of Cambridge
Academics of the University of Manchester
Fellows of the Institute of Mathematics and its Applications
|
Kevin Hyland, OBE (born 1963) was the United Kingdom’s first Independent Anti-Slavery Commissioner, leading efforts to tackle slavery and human trafficking. He left the post in May 2018 and was succeeded by Dame Sara Thornton. He is the Chair of IHRB's Leadership Group for Responsible Recruitment, collaboration between leading companies and expert organisations to drive positive change in the way that migrant workers are recruited. He was formerly head of the London Metropolitan Police Service’s Human Trafficking Unit.
Police career
Hyland was a police officer for 30 years until retiring from the force as a detective inspector in 2014. As a detective Hyland specialised in various crimes throughout his policing career including homicide, gun crime, anti-corruption and then human trafficking and slavery. When working as a senior investigating officer, Hyland was responsible for the convictions of a large number of international organised crime groups, which included conducting multi-national JITs (joint investigation teams) bi-lateral prosecutions various criminal offences including money laundering, corruption, sexual exploitation and human trafficking.
In 2010 Hyland was appointed as the lead for the London Metropolitan Police’s Human Trafficking Unit. During Hyland’s tenure the London Metropolitan Police saw an increase in victim identifications and successful prosecutions of traffickers. He retired from the MPS in 2014 with the title of Detective Inspector, after some 30 years of service, in order to accept the position of "anti-slavery tsar".
Independent Anti-Slavery Commissioner
The creation of an Independent Commissioner is one of the main provisions of the UK's Modern Slavery Act 2015. Hyland was appointed to the role in November 2014 and acted as 'designate' Commissioner until the Bill received Royal Assent in March 2015, when he became Commissioner. He resigned in May 2018.
Kevin Hyland alleged that young children are made to do begging, pickpocketing and shoplifting in a manner similar to what happens in the novel, Oliver Twist by Charles Dickens. Hyland maintains 151 convictions for slavery-related offences occurred in 2014 which he felt was far too few. Hyland claims police are doing too little to prevent contemporary slavery in the UK:
Hyland wanted police forces to make dealing with slavery "one of the highest priorities".
In 2016 Hyland urged members of the public in London to report any brothels and flats used for human trafficking. He highlighted risk of labour exploitation on high streets in car washes and nail bars. He also called on ministers to deport foreign diplomats found to be keeping staff in slave conditions, and to implement reforms intended to make it easier for victims to escape abusive employers.
In 2015 he led efforts for inclusion of human trafficking and modern slavery in the 15-year UN Sustainable Development Goals. This was secured as SDG 8.7 on the final day of negotiations at the UN in New York in the summer of 2015. This has resulted in many global efforts focussed on fighting modern slavery and human trafficking, including Alliance 8.7, an initiative led by the International Labour Organisation.
Santa Marta Group
Hyland helped to establish the Santa Marta Group, a body comprising international law enforcement agencies, civil society, NGOs and the Catholic Church.
The Group was launched by Pope Francis at the Vatican in April 2014, and is named after the Papal residence, where delegates stayed during the first meeting. At the launch Pope Francis described human trafficking as "an open wound on the body of contemporary society; a crime against humanity".
The Group was developed by the Catholic Bishops' Conference of England and Wales in collaboration with the London Metropolitan Police and is led by Cardinal Vincent Nichols, the Archbishop of Westminster.
Honours
Hyland was appointed Officer of the Order of the British Empire (OBE) for "services to Combating Human Trafficking" in the 2015 New Year Honours List.
References
External links
"Commissioner signs trafficking declaration at the Vatican", crimeandjustice.co.uk, 4 October 2014; archived 19 January 2015
Metropolitan Police officers
Modern slavery in the United Kingdom
Human trafficking in the United Kingdom
Officers of the Order of the British Empire
1963 births
Living people
British people of Irish descent
British Roman Catholics
Date of birth missing (living people)
Place of birth missing (living people)
|
```xml
<vector xmlns:android="path_to_url" android:height="34.0dp" android:tint="?attr/colorControlNormal" android:viewportHeight="15" android:viewportWidth="15" android:width="34.0dp">
<path android:fillColor="@android:color/white" android:pathData="M15 0.5C15 0.5 15 15 15 15L1 15C0.75 15 0.75 14 1 14L3 14C3 14 3 9.5 3 9.5C3 9.25 4 9.25 4 9.5C4 9.5 4 13.52 4 13.52L7.5 11.85C7.5 11.85 7.5 7.5 7.5 7.5C7.5 7.25 8.5 7.25 8.5 7.5C8.5 7.5 8.5 11.38 8.5 11.38L12 9.7C12 9.7 12 5.5 12 5.5C12 5.25 13 5.25 13 5.5C13 5.5 13 9.23 13 9.23L14 8.75C14 8.75 14 0.5 14 0.5C14 0.25 15 0.25 15 0.5zM14 9.75L13 10.2L13 14L14 14L14 9.75zM12 10.7L8.5 12.35L8.5 14L12 14L12 10.7zM7.5 12.85L5.1 14L7.5 14L7.5 12.85zM2.5 12L0.25 12C0 12 0 13 0.25 13L2.5 13C2.75 13 2.75 12 2.5 12zM7 10L4.75 10C4.5 10 4.5 11 4.75 11L7 11C7.25 11 7.25 10 7 10zM11.5 8L9.25 8C9 8 9 9 9.25 9L11.5 9C11.75 9 11.75 8 11.5 8zM4.5 8L2 8C1.75 8 1.75 9 2 9C2 9 4.5 9 4.5 9C4.75 9 4.75 8 4.5 8zM9 6L6.5 6C6.25 6 6.25 7 6.5 7L9 7C9.25 7 9.25 6 9 6zM13.5 4L11 4C10.75 4 10.75 5 11 5L13.5 5C13.75 5 13.75 4 13.5 4z"/>
</vector>
```
|
```c++
#include "mindmapeditorconfig.h"
#include "mainconfig.h"
#define READSTR(key) readString(appObj, userObj, (key))
#define READBOOL(key) readBool(appObj, userObj, (key))
#define READINT(key) readInt(appObj, userObj, (key))
using namespace vnotex;
MindMapEditorConfig::MindMapEditorConfig(ConfigMgr *p_mgr, IConfig *p_topConfig)
: IConfig(p_mgr, p_topConfig)
{
m_sessionName = QStringLiteral("mindmap_editor");
}
void MindMapEditorConfig::init(const QJsonObject &p_app,
const QJsonObject &p_user)
{
const auto appObj = p_app.value(m_sessionName).toObject();
const auto userObj = p_user.value(m_sessionName).toObject();
loadEditorResource(appObj, userObj);
}
QJsonObject MindMapEditorConfig::toJson() const
{
QJsonObject obj;
obj[QStringLiteral("editor_resource")] = saveEditorResource();
return obj;
}
void MindMapEditorConfig::loadEditorResource(const QJsonObject &p_app, const QJsonObject &p_user)
{
const QString name(QStringLiteral("editor_resource"));
if (MainConfig::isVersionChanged()) {
bool needOverride = p_app[QStringLiteral("override_editor_resource")].toBool();
if (needOverride) {
qInfo() << "override \"editor_resource\" in user configuration due to version change";
m_editorResource.init(p_app[name].toObject());
return;
}
}
if (p_user.contains(name)) {
m_editorResource.init(p_user[name].toObject());
} else {
m_editorResource.init(p_app[name].toObject());
}
}
QJsonObject MindMapEditorConfig::saveEditorResource() const
{
return m_editorResource.toJson();
}
const WebResource &MindMapEditorConfig::getEditorResource() const
{
return m_editorResource;
}
```
|
Farmington High School may refer to:
Farmington High School (Arkansas), Farmington, Arkansas
Farmington High School (Connecticut), Farmington, Connecticut
Farmington Central High School (Illinois), Farmington, Illinois
Farmington High School (Kentucky), Farmington, Kentucky
Farmington Central High School (Michigan), Farmington, Michigan
Farmington High School (Michigan), Farmington, Michigan
Farmington Senior High School (Minnesota), Farmington, Minnesota
Farmington Senior High School (Missouri), Farmington, Missouri
Farmington High School (New Mexico), Farmington, New Mexico
Farmington Senior High School (New Hampshire), Farmington, New Hampshire
Farmington High School (Utah), Farmington, Utah
Farmington High School (West Virginia), Farmington, West Virginia
North Farmington High School, Farmington Hills, Michigan
|
```javascript
import React from 'react';
import B from './b';
export default function A() {
return <B />;
}
```
|
```html
<div class="navbar-inner">
<div class="navbar-container">
<!-- Navbar Barnd -->
<div class="navbar-header pull-left">
<a href="#" class="navbar-brand">
<small>
<img src="assets/img/logo.png" ng-if="!settings.rtl" alt=""/>
</small>
</a>
</div>
<!-- /Navbar Barnd -->
<!-- Sidebar Collapse -->
<div class="sidebar-collapse"></div>
<!-- /Sidebar Collapse -->
<!-- Account Area and Settings --->
<div class="navbar-header pull-right" ng-controller="LoginCtrl as loginCtrl">
<div class="navbar-account">
<ul class="account-area">
<li>
<a class="login-area dropdown-toggle" data-toggle="dropdown">
<div class="avatar" title="View your public profile">
<!--<img src="assets/img/avatars/adam-jansen.jpg">-->
</div>
<section>
<h2>
<span class="profile" style="min-width: 60px;">
<span style="text-align: center">{{user.name}}</span>
</span>
</h2>
</section>
</a>
<!--Login Area Dropdown-->
<ul class="pull-right dropdown-menu dropdown-arrow dropdown-login-area">
<li class="username"><a>{{user.name}}</a></li>
<li class="email"><a></a></li>
<!--Avatar Area-->
<!--Avatar Area-->
<li class="edit">
<a href="profile.html" class="pull-left">Profile</a>
<a href="#" class="pull-right">Setting</a>
</li>
<!--Theme Selector Area-->
<li class="theme-area">
<ul class="colorpicker">
<li><a class="colorpick-btn" href="" style="background-color:#5DB2FF;" skin-changer
rel="assets/css/skins/blue.min.css"></a></li>
<li><a class="colorpick-btn" href="" style="background-color:#2dc3e8;" skin-changer
rel="assets/css/skins/azure.min.css"></a></li>
<li><a class="colorpick-btn" href="" style="background-color:#03B3B2;" skin-changer
rel="assets/css/skins/teal.min.css"></a></li>
<li><a class="colorpick-btn" href="" style="background-color:#53a93f;" skin-changer
rel="assets/css/skins/green.min.css"></a></li>
<li><a class="colorpick-btn" href="" style="background-color:#FF8F32;" skin-changer
rel="assets/css/skins/orange.min.css"></a></li>
<li><a class="colorpick-btn" href="" style="background-color:#cc324b;" skin-changer
rel="assets/css/skins/pink.min.css"></a></li>
<li><a class="colorpick-btn" href="" style="background-color:#AC193D;" skin-changer
rel="assets/css/skins/darkred.min.css"></a></li>
<li><a class="colorpick-btn" href="" style="background-color:#8C0095;" skin-changer
rel="assets/css/skins/purple.min.css"></a></li>
<li><a class="colorpick-btn" href="" style="background-color:#0072C6;" skin-changer
rel="assets/css/skins/darkblue.min.css"></a></li>
<li><a class="colorpick-btn" href="" style="background-color:#585858;" skin-changer
rel="assets/css/skins/gray.min.css"></a></li>
<li><a class="colorpick-btn" href="" style="background-color:#474544;" skin-changer
rel="assets/css/skins/black.min.css"></a></li>
<li><a class="colorpick-btn" href="" style="background-color:#001940;" skin-changer
rel="assets/css/skins/deepblue.min.css"></a></li>
</ul>
</li>
<!--/Theme Selector Area-->
<li class="dropdown-footer">
<a href="javascript:void(0);" ng-click="loginCtrl.logout()">
Sign out
</a>
</li>
</ul>
<!--/Login Area Dropdown-->
</li>
<!-- /Account Area -->
<!--Note: notice that setting div must start right after account area list.
no space must be between these elements-->
<!-- Settings -->
</ul>
<div class="setting">
</div>
<div class="setting-container">
<label>
<input type="checkbox" id="checkbox_fixednavbar" ng-model="settings.fixed.navbar">
<span class="text">Fixed Navbar</span>
</label>
<label>
<input type="checkbox" id="checkbox_fixedsidebar" ng-model="settings.fixed.sidebar">
<span class="text">Fixed SideBar</span>
</label>
<label>
<input type="checkbox" id="checkbox_fixedbreadcrumbs" ng-model="settings.fixed.breadcrumbs">
<span class="text">Fixed BreadCrumbs</span>
</label>
<label>
<input type="checkbox" id="checkbox_fixedheader" ng-model="settings.fixed.header">
<span class="text">Fixed Header</span>
</label>
</div>
<!-- Settings -->
</div>
</div>
<!-- /Account Area and Settings -->
</div>
</div>
```
|
Photorealism is a genre of art that encompasses painting, drawing and other graphic media, in which an artist studies a photograph and then attempts to reproduce the image as realistically as possible in another medium. Although the term can be used broadly to describe artworks in many different media, it is also used to refer specifically to a group of paintings and painters of the American art movement that began in the late 1960s and early 1970s.
History
Origins
As a full-fledged art movement, Photorealism evolved from Pop Art and as a counter to Abstract Expressionism as well as Minimalist art movements in the late 1960s and early 1970s in the United States. Photorealists use a photograph or several photographs to gather the information to create their paintings and it can be argued that the use of a camera and photographs is an acceptance of Modernism. However, the admittance to the use of photographs in Photorealism was met with intense criticism when the movement began to gain momentum in the late 1960s, despite the fact that visual devices had been used since the fifteenth century to aid artists with their work.
Louis K. Meisel states in his books and lectures the following: The invention of photography in the nineteenth century had three effects on art: portrait and scenic artists were deemed inferior to the photograph and many turned to photography as careers; within nineteenth- and twentieth-century art movements it is well documented that artists used the photograph as source material and as an aid—however, they went to great lengths to deny the fact fearing that their work would be misunderstood as imitations; and through the photograph's invention artists were open to a great deal of new experimentation. Thus, the culmination of the invention of the photograph was a break in art's history towards the challenge facing the artist—since the earliest known cave drawings—trying to replicate the scenes they viewed.
By the time the Photorealists began producing their bodies of work the photograph had become the leading means of reproducing reality and abstraction was the focus of the art world. Realism continued as an ongoing art movement, even experiencing a reemergence in the 1930s, but by the 1950s modernist critics and Abstract Expressionism had minimalized realism as a serious art undertaking. Though Photorealists share some aspects of American realists, such as Edward Hopper, they tried to set themselves as much apart from traditional realists as they did Abstract Expressionists. Photorealists were much more influenced by the work of Pop artists and were reacting against Abstract Expressionism.
Pop Art and photorealism were both reactionary movements stemming from the ever-increasing and overwhelming abundance of photographic media, which by the mid 20th century had grown into such a massive phenomenon that it was threatening to lessen the value of imagery in art. However, whereas the Pop artists were primarily pointing out the absurdity of much of the imagery (especially in commercial usage), the Photorealists were trying to reclaim and exalt the value of an image.
The association of photorealism with trompe-l'œil is a wrongly attributed comparison, an error in observation or interpretation made by many critics of the 1970s and 1980s. Trompe-l'œil paintings attempt to "fool the eye" and make the viewer think he is seeing an actual object, not a painted one. When observing a Photorealist painting, the viewer is always aware that they are looking at a painting.
Definition
The word Photorealism was coined by Louis K. Meisel in 1969 and appeared in print for the first time in 1970 in a Whitney Museum catalogue for the show "Twenty-two Realists." It is also sometimes labeled as Super-Realism, New Realism, Sharp Focus Realism, or Hyper-Realism.
Louis K. Meisel, two years later, developed a five-point definition at the request of Stuart M. Speiser, who had commissioned a large collection of works by the Photorealists, which later developed into a traveling show known as 'Photo-Realism 1973: The Stuart M. Speiser Collection', which was donated to the Smithsonian in 1978 and is shown in several of its museums as well as traveling under the auspices of 'site'. The definition for the 'originators' was as follows:
The Photo-Realist uses the camera and photograph to gather information.
The Photo-Realist uses a mechanical or semi-mechanical means to transfer the information to the canvas.
The Photo-Realist must have the technical ability to make the finished work appear photographic.
The artist must have exhibited work as a Photo-Realist by 1972 to be considered one of the central Photo-Realists.
The artist must have devoted at least five years to the development and exhibition of Photo-Realist work.
Styles
Photorealist painting cannot exist without the photograph. In Photorealism, change and movement must be frozen in time which must then be accurately represented by the artist. Photorealists gather their imagery and information with the camera and photograph. Once the photograph is developed (usually onto a photographic slide) the artist will systematically transfer the image from the photographic slide onto canvases. Usually this is done either by projecting the slide onto the canvas or by using traditional grid techniques. The resulting images are often direct copies of the original photograph but are usually larger than the original photograph or slide. This results in the photorealist style being tight and precise, often with an emphasis on imagery that requires a high level of technical prowess and virtuosity to simulate, such as reflections in specular surfaces and the geometric rigor of man-made environs.
Artists
The first generation of American Photorealists includes the painters Richard Estes, Ralph Goings, Chuck Close, Charles Bell, Audrey Flack, Don Eddy, Robert Bechtle, Ron Kleemann, Richard McLean, John Salt, , and Tom Blackwell. Often working independently of each other and with widely different starting points, these original Photorealists routinely tackled mundane or familiar subjects in traditional art genres--landscapes (mostly urban rather than naturalistic), portraits, and still lifes.
With the birth of the Photorealist movement, many painters who were related to Photorealism, continued to pursue and refine their techniques; they became the second generation of Photorealists. These painters included John Baeder, Hilo Chen, Jack Mendenhall, Ken Marschall, David Parrish and Idelle Weber.
In the United Kingdom of Great Britain and Northern Ireland, photorealist approaches were favoured by many artists including Mike Gorman and Eric Scott. The introduction of these European painters to a wider US audience was brought about through the 1982 'Superhumanism' exhibition at the Arnold Katzen Gallery, New York.
Though the movement is primarily associated with painting, Duane Hanson and John DeAndrea are sculptors associated with photorealism for their painted, lifelike sculptures of average people that were complete with simulated hair and real clothes. They are called Verists.
Since 2000
Though the height of Photorealism was in the 1970s, the movement continues and includes several of the original photorealists as well as many of their contemporaries. According to Meisel and Chase's Photorealism at the Millennium, only eight of the original thirteen photorealists were still creating Photorealist work in 2002. As of September 2020, Richard Estes is the only remaining original Photorealist actively working in the Photorealist style.
Artists Robert Bechtle, Charles Bell, Tom Blackwell, Ralph Goings, John Kacere, Ron Kleemann have died; Audrey Flack, Chuck Close, Don Eddy, and have moved away from Photorealism; and Robert Cottingham no longer considers himself a photorealist.
Newer Photorealists are building upon the foundations set by the original Photorealists. Examples would be the influence of Richard Estes in works by Anthony Brunelli or the influence of Ralph Goings and Charles Bell in works by Glennray Tutor. However, this has led many to move on from the strict definition of photorealism as the emulation of the photograph. Photorealism is also no longer simply an American art movement. Starting with Franz Gertsch in the 1980s Clive Head, Raphaella Spence, Bertrand Meniel, and Roberto Bernardi are several European artists associated with photorealism that have emerged since the mid-1990s. This internationalization of photorealism is also seen in photorealist events, such as The Prague Project, in which American and non-American photorealist painters have traveled together to locations including Prague, Zurich, Monaco and New York, to work alongside each other in producing work.
The evolution of technology has brought forth photorealistic paintings that exceed what was thought possible with paintings; these newer paintings by the photorealists are sometimes referred to as "Hyperrealism." With new technology in cameras and digital equipment, artists are able to be far more precision-oriented and can produce imagery using a wider range of media. The artist Bill Fink has developed his own technique for creating photorealistic images using soil, pollen, human hair, and cremated human remains.
Photorealism's influence and popularity continues to grow, with new books such as Juxtapoz's 2014 book entitled Hyperreal detailing current trends within the artistic genre.
List of photorealists
Original photorealists
Significant artists whose work helped define Photorealism:
John Baeder (born 1938)
Robert Bechtle (1932–2020)
Charles Bell (1935–1995)
Tom Blackwell (1938–2020)
Chuck Close (1940–2021)
Robert Cottingham (born 1935)
Don Eddy (born 1944)
Richard Estes (born 1932)
Audrey Flack (born 1931)
Ralph Goings (1928–2016)
Ian Hornak (1944–2002)
Howard Kanovitz (1929–2009)
John Kacere (1920–1999)
Ron Kleemann (1937–2014)
Malcolm Morley (1931–2018)
John Salt (born 1937)
Ben Schonzeit (born 1942)
Photorealists
Significant artists whose work meets the criteria of Photorealism:
Linda Bacon
Mike Bayne
Roberto Bernardi (born 1974)
Arne Besser
Anthony Brunelli (born 1968)
Bryan Charnley (1949–1991)
Hilo Chen (born 1942)
Davis Cone (born 1950)
Randy Dudley (born 1950)
Franz Gertsch (born 1930)
Robert Gniewek (born 1951)
Gus Heinze (born 1926)
Gottfried Helnwein (born 1948)
Don Jacot (born 1949)
Noel Mahaffey (born 1944)
Dennis James Martin (1956–2001)
Jack Mendenhall (born 1937)
Kim Mendenhall
Betrand Meniel (born 1961)
Reynard Milici (born 1942)
Robert Neffson (born 1949)
William Nichols (born 1942)
Jerry Ott (born 1947)
James Torlakson (born 1951)
Denis Peterson
Tjalf Sparnaay (born 1954)
Paul Staiger (born 1941)
Glennray Tutor (born 1950)
Rod Penner (born 1965)
Raphaella Spence (born 1978)
Idelle Weber (1932–2020)
Ken Orton (born 1951)
Other photorealists
Clive Head (born 1965)
See also
Abstract Illusionism
Contemporary art
Contemporary realism
History of art
Hyperrealism (visual arts)
Photorealistic rendering
Realism (arts)
Trompe-l'œil
Art of Europe
Western painting
Bibliography
Auping, Michael; Bishop, Janet; Ray, Charles; and Weinberg, Jonathan (2005), Robert Bechtle: A Retrospective. Berkeley, California: University of California Press. .
Chalumeau, Jean-Luc (2007), Peinture et Photographie: Pop art, figuration narrative, hyperréalisme, nouveaux pop. Paris: Editions du Chêne. .
Chase, Linda (1988), Ralph Goings: Essay/Interview. New York: Abrams. .
Chase, Linda (ed.) (2001), Photorealism: The Liff Collection. Naples, Florida: Naples Museum of Art. .
Geldzahler, Henry and Meisel, Louis K. (1991), Charles Bell: The Complete Works, 1970–1990. New York: Abrams. .
Lindey, Christine (1980), Superrealist Painting and Sculpture, New York: William Morrow and Company.
Meisel, Louis K. (1989), Photorealism. New York: Abradale/Abrams. .
Meisel, Louis K. (1993), Photorealism Since 1980. New York: Abrams. .
Meisel, Louis K. and Chase, Linda. (2002), Photorealism at the Millennium. New York: Abrams. .
Meisel, Louis K. and Perreault, John (1986), Richard Estes: The Complete Paintings, 1966-1985. New York:Abrams. .
Paraskos, Michael (2013), Scarborough Realists Now. London: Orage Press. .
Paraskos, Michael (2010), Clive Head. London: Lund Humphries. .
Wilmerding, John (2006), Richard Estes. New York: Rizzoli. .
References
External links
Art movements
American art movements
Contemporary art movements
Modern paintings
|
Kani Ganji (, also Romanized as Kānī Ganjī; also known as Ganjī, Kān Ganjī, and Kānī Ganjeh) is a village in Panjeh Ali Rural District, in the Central District of Qorveh County, Kurdistan Province, Iran. At the 2006 census, its population was 584, in 143 families. The village is populated by Kurds.
References
Towns and villages in Qorveh County
Kurdish settlements in Kurdistan Province
|
A Mother's Devotion () is a 1966 Soviet drama film directed by Mark Donskoy.
Plot
The film takes place in 1900-1917. The film tells about a woman who begins to understand that her children will become her faithful followers, so she becomes stronger.
Cast
Nina Menshikova
Rodion Nakhapetov
Gennadi Chertov
Yuriy Solomin
Tamara Loginova
Aleksandra Moskalyova
Yelmira Kapustina
Nadezhda Fedosova
Viktor Shakhov
Georgi Yepifantsev
References
External links
1966 films
1960s Russian-language films
Soviet drama films
1966 drama films
|
Blaž Kavčič was the defending champion, but he chose to compete at the French Open instead.Björn Phau won in the final 7–6(8–6), 2–6, 6–2, against Carlos Berlocq.
Seeds
Draw
Finals
Top half
Bottom half
References
Main Draw
Qualifying Draw
Alessandria Challenger - Singles
Alessandria Challenger
|
```haskell
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE Trustworthy #-}
your_sha256_hash-------------
-- |
-- Module : Data.Functor.Identity
-- (c) Oregon Graduate Institute of Science and Technology 2001
--
-- Maintainer : ross@soi.city.ac.uk
-- Stability : experimental
-- Portability : portable
--
-- The identity functor and monad.
--
-- This trivial type constructor serves two purposes:
--
-- * It can be used with functions parameterized by functor or monad classes.
--
-- * It can be used as a base monad to which a series of monad
-- transformers may be applied to construct a composite monad.
-- Most monad transformer modules include the special case of
-- applying the transformer to 'Identity'. For example, @State s@
-- is an abbreviation for @StateT s 'Identity'@.
--
-- @since 4.8.0.0
your_sha256_hash-------------
module Data.Functor.Identity (
Identity(..),
) where
import Control.Monad.Fix
import Data.Bits (Bits, FiniteBits)
import Data.Coerce
import Data.Foldable
import Data.Functor.Utils ((#.))
import Foreign.Storable (Storable)
import GHC.Arr (Ix)
import GHC.Base ( Applicative(..), Eq(..), Functor(..), Monad(..)
, Semigroup, Monoid, Ord(..), ($), (.) )
import GHC.Enum (Bounded, Enum)
import GHC.Float (Floating, RealFloat)
import GHC.Generics (Generic, Generic1)
import GHC.Num (Num)
import GHC.Read (Read(..), lex, readParen)
import GHC.Real (Fractional, Integral, Real, RealFrac)
import GHC.Show (Show(..), showParen, showString)
import GHC.Types (Bool(..))
-- | Identity functor and monad. (a non-strict monad)
--
-- @since 4.8.0.0
newtype Identity a = Identity { runIdentity :: a }
deriving ( Bits, Bounded, Enum, Eq, FiniteBits, Floating, Fractional
, Generic, Generic1, Integral, Ix, Semigroup, Monoid, Num, Ord
, Real, RealFrac, RealFloat, Storable)
-- | This instance would be equivalent to the derived instances of the
-- 'Identity' newtype if the 'runIdentity' field were removed
--
-- @since 4.8.0.0
instance (Read a) => Read (Identity a) where
readsPrec d = readParen (d > 10) $ \ r ->
[(Identity x,t) | ("Identity",s) <- lex r, (x,t) <- readsPrec 11 s]
-- | This instance would be equivalent to the derived instances of the
-- 'Identity' newtype if the 'runIdentity' field were removed
--
-- @since 4.8.0.0
instance (Show a) => Show (Identity a) where
showsPrec d (Identity x) = showParen (d > 10) $
showString "Identity " . showsPrec 11 x
-- your_sha256_hash-----------
-- Identity instances for Functor and Monad
-- | @since 4.8.0.0
instance Foldable Identity where
foldMap = coerce
elem = (. runIdentity) #. (==)
foldl = coerce
foldl' = coerce
foldl1 _ = runIdentity
foldr f z (Identity x) = f x z
foldr' = foldr
foldr1 _ = runIdentity
length _ = 1
maximum = runIdentity
minimum = runIdentity
null _ = False
product = runIdentity
sum = runIdentity
toList (Identity x) = [x]
-- | @since 4.8.0.0
instance Functor Identity where
fmap = coerce
-- | @since 4.8.0.0
instance Applicative Identity where
pure = Identity
(<*>) = coerce
liftA2 = coerce
-- | @since 4.8.0.0
instance Monad Identity where
m >>= k = k (runIdentity m)
-- | @since 4.8.0.0
instance MonadFix Identity where
mfix f = Identity (fix (runIdentity . f))
```
|
```css
How to easily check browser compatibility of a feature
Make text unselectable
Writing comments in CSS
Default to a transparent `border-color` before adding a border to on `:hover` state elements
Matching images to a website's color scheme
```
|
The South Fork South Platte River is a tributary of the South Platte River, approximately long, in central Colorado in the United States. It is located near the headwaters of the South Platte in Park County, Colorado and drains part of the intermontane grassland basin of South Park. It forms the South Platte by its confluence with the Middle Fork South Platte River in southern South Park.
It rises on the eastern flank of the Mosquito Range, below Weston Pass north of Buffalo Peaks in the Pike National Forest. It descends through a short narrow gorge to the southeast, then turns east to emerge into the eastern side of South Park approximately 10 miles (16 km) south of the town of Fairplay. It turns south, skirting the base of the mountains and flowing along the eastern side of U.S. Highway 285, then turns east, winding in a course that roughly follows U.S. Highway 24. It joins the Middle Fork to form the main branch of the South Platte near the community of Hartsel.
See also
List of rivers of Colorado
References
Rivers of Colorado
Tributaries of the Platte River
Rivers of Park County, Colorado
|
Irattimadhuram is a 1982 Indian Malayalam film, directed by Sreekumaran Thampi. The film stars Prem Nazir, Krishnachandran, K. R. Vijaya and Master Rajakumaran Thampi in the lead roles. The film has musical score by Shyam.
Cast
Prem Nazir as Achuthan Nair
Krishnachandran as Ramu
K. R. Vijaya as Madhavikutty
Master Rajakumaran Thampi as Ravikuttan
Master Khaja Sharif
Shanavas as Surendran
Shivaji as Balan
Sumalatha as Sangeetha
Sukumari as Kalyaniyamma
Adoor Bhasi as Thorappan Panikkar
Jagathy Sreekumar as Unnikrishnan
Balan K. Nair as K. B. Menon
P. K. Abraham as Vakkel Mahadevan
Vijayalakshmi as Mrs Panikkar
Guddi Maruti as Omana
Soundtrack
The music was composed by Shyam and the lyrics were written by Sreekumaran Thampi.
References
External links
1982 films
1980s Malayalam-language films
Films directed by Sreekumaran Thampi
|
```forth
*> \brief \b CLAQHB scales a Hermitian band matrix, using scaling factors computed by cpbequ.
*
* =========== DOCUMENTATION ===========
*
* Online html documentation available at
* path_to_url
*
*> \htmlonly
*> Download CLAQHB + dependencies
*> <a href="path_to_url">
*> [TGZ]</a>
*> <a href="path_to_url">
*> [ZIP]</a>
*> <a href="path_to_url">
*> [TXT]</a>
*> \endhtmlonly
*
* Definition:
* ===========
*
* SUBROUTINE CLAQHB( UPLO, N, KD, AB, LDAB, S, SCOND, AMAX, EQUED )
*
* .. Scalar Arguments ..
* CHARACTER EQUED, UPLO
* INTEGER KD, LDAB, N
* REAL AMAX, SCOND
* ..
* .. Array Arguments ..
* REAL S( * )
* COMPLEX AB( LDAB, * )
* ..
*
*
*> \par Purpose:
* =============
*>
*> \verbatim
*>
*> CLAQHB equilibrates an Hermitian band matrix A using the scaling
*> factors in the vector S.
*> \endverbatim
*
* Arguments:
* ==========
*
*> \param[in] UPLO
*> \verbatim
*> UPLO is CHARACTER*1
*> Specifies whether the upper or lower triangular part of the
*> symmetric matrix A is stored.
*> = 'U': Upper triangular
*> = 'L': Lower triangular
*> \endverbatim
*>
*> \param[in] N
*> \verbatim
*> N is INTEGER
*> The order of the matrix A. N >= 0.
*> \endverbatim
*>
*> \param[in] KD
*> \verbatim
*> KD is INTEGER
*> The number of super-diagonals of the matrix A if UPLO = 'U',
*> or the number of sub-diagonals if UPLO = 'L'. KD >= 0.
*> \endverbatim
*>
*> \param[in,out] AB
*> \verbatim
*> AB is COMPLEX array, dimension (LDAB,N)
*> On entry, the upper or lower triangle of the symmetric band
*> matrix A, stored in the first KD+1 rows of the array. The
*> j-th column of A is stored in the j-th column of the array AB
*> as follows:
*> if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
*> if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
*>
*> On exit, if INFO = 0, the triangular factor U or L from the
*> Cholesky factorization A = U**H *U or A = L*L**H of the band
*> matrix A, in the same storage format as A.
*> \endverbatim
*>
*> \param[in] LDAB
*> \verbatim
*> LDAB is INTEGER
*> The leading dimension of the array AB. LDAB >= KD+1.
*> \endverbatim
*>
*> \param[out] S
*> \verbatim
*> S is REAL array, dimension (N)
*> The scale factors for A.
*> \endverbatim
*>
*> \param[in] SCOND
*> \verbatim
*> SCOND is REAL
*> Ratio of the smallest S(i) to the largest S(i).
*> \endverbatim
*>
*> \param[in] AMAX
*> \verbatim
*> AMAX is REAL
*> Absolute value of largest matrix entry.
*> \endverbatim
*>
*> \param[out] EQUED
*> \verbatim
*> EQUED is CHARACTER*1
*> Specifies whether or not equilibration was done.
*> = 'N': No equilibration.
*> = 'Y': Equilibration was done, i.e., A has been replaced by
*> diag(S) * A * diag(S).
*> \endverbatim
*
*> \par Internal Parameters:
* =========================
*>
*> \verbatim
*> THRESH is a threshold value used to decide if scaling should be done
*> based on the ratio of the scaling factors. If SCOND < THRESH,
*> scaling is done.
*>
*> LARGE and SMALL are threshold values used to decide if scaling should
*> be done based on the absolute size of the largest matrix element.
*> If AMAX > LARGE or AMAX < SMALL, scaling is done.
*> \endverbatim
*
* Authors:
* ========
*
*> \author Univ. of Tennessee
*> \author Univ. of California Berkeley
*> \author Univ. of Colorado Denver
*> \author NAG Ltd.
*
*> \ingroup laqhb
*
* =====================================================================
SUBROUTINE CLAQHB( UPLO, N, KD, AB, LDAB, S, SCOND, AMAX,
$ EQUED )
*
* -- LAPACK auxiliary routine --
* -- LAPACK is a software package provided by Univ. of Tennessee, --
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
* .. Scalar Arguments ..
CHARACTER EQUED, UPLO
INTEGER KD, LDAB, N
REAL AMAX, SCOND
* ..
* .. Array Arguments ..
REAL S( * )
COMPLEX AB( LDAB, * )
* ..
*
* =====================================================================
*
* .. Parameters ..
REAL ONE, THRESH
PARAMETER ( ONE = 1.0E+0, THRESH = 0.1E+0 )
* ..
* .. Local Scalars ..
INTEGER I, J
REAL CJ, LARGE, SMALL
* ..
* .. External Functions ..
LOGICAL LSAME
REAL SLAMCH
EXTERNAL LSAME, SLAMCH
* ..
* .. Intrinsic Functions ..
INTRINSIC MAX, MIN, REAL
* ..
* .. Executable Statements ..
*
* Quick return if possible
*
IF( N.LE.0 ) THEN
EQUED = 'N'
RETURN
END IF
*
* Initialize LARGE and SMALL.
*
SMALL = SLAMCH( 'Safe minimum' ) / SLAMCH( 'Precision' )
LARGE = ONE / SMALL
*
IF( SCOND.GE.THRESH .AND. AMAX.GE.SMALL .AND. AMAX.LE.LARGE ) THEN
*
* No equilibration
*
EQUED = 'N'
ELSE
*
* Replace A by diag(S) * A * diag(S).
*
IF( LSAME( UPLO, 'U' ) ) THEN
*
* Upper triangle of A is stored in band format.
*
DO 20 J = 1, N
CJ = S( J )
DO 10 I = MAX( 1, J-KD ), J - 1
AB( KD+1+I-J, J ) = CJ*S( I )*AB( KD+1+I-J, J )
10 CONTINUE
AB( KD+1, J ) = CJ*CJ*REAL( AB( KD+1, J ) )
20 CONTINUE
ELSE
*
* Lower triangle of A is stored.
*
DO 40 J = 1, N
CJ = S( J )
AB( 1, J ) = CJ*CJ*REAL( AB( 1, J ) )
DO 30 I = J + 1, MIN( N, J+KD )
AB( 1+I-J, J ) = CJ*S( I )*AB( 1+I-J, J )
30 CONTINUE
40 CONTINUE
END IF
EQUED = 'Y'
END IF
*
RETURN
*
* End of CLAQHB
*
END
```
|
Nikolay Alexandrovich Bestuzhev (Russian: Николай Александрович Бестужев; 13 April 1791, Saint Petersburg – 27 May 1855, Novoselenginsk) was a Russian Navy officer, writer, inventor and portrait artist; associated with the Decembrist revolt.
Biography
He was born to a noble family. His father, , was a writer and government councilor. His brothers, Alexander, , , and were also writers, military officers and Decembrists.
He entered the Sea Cadet Corps school in 1802 and graduated in 1809. While there, he audited classes taught by Andrey Voronikhin at the Imperial Academy of Arts. In 1810, he became a Lieutenant in the Corps. In 1815, he participated in naval actions in the Netherlands. He was appointed an Assistant Superintendent for the Baltic lighthouse in Kronstadt in 1820. Two years later, he reorganized the lithography department at the Admiralty, for which he was awarded the Order of Saint Vladimir, and began writing a history of the fleet.
In 1824, he was promoted to Lieutenant-Commander and, shortly after, was named Director of the Admiralty's museum, where he was known as "The Mummy". During this time he also contributed to the journals Polar Star (edited by his brother, Alexander) and Syn otechestva (Son of the Fatherland). He also served with the Bureau of Censorship and, in 1825, became a member of the Imperial Society for the Encouragement of the Arts.
These achievements were short-lived, however. Since 1824, he had been a member of the "", a secret organization headed by Kondraty Ryleyev, and had written a "Manifesto to the Russian People". Following the Decembrist riot on Peter's Square, during which he led a unit of rebellious Naval Equipage of the Guard, he went into hiding but was found and arrested. He was taken to the Peter and Paul Fortress and, on 10 July 1826, was convicted of engaging in subversive activities and mutiny. He was sentenced to katorga (hard labor) for life.
Life in Siberia
The following month, he and his brother Mikhail were taken to Shlisselburg Fortress. In September 1827, they were transferred to Siberia and placed in a special prison at the confluence of the Chita and Ingoda rivers. In 1830, they were moved again, into the town of Petrovsk-Zabaykalsky. In 1832, their terms were reduced to fifteen years. Shortly after, he entered into a common-law marriage and had two children; one of whom was Alexey Startsev, a major figure in the commercial trade between Russia and China. The year 1839 found him and his brother transferred to Novoselenginsk, where he chose to remain; dying there in 1855.
Despite the harsh conditions, he painted numerous portraits of his fellow Decembrists, the family members who had followed them there and local villagers; at first in watercolor, later in oils. At the end of his term, he spent 1841 in Irkutsk, doing portraits of government officials.
He was also engaged as a cobbler, lathe operator and watchmaker. In that capacity, he developed a design for a high-precision chronometer based on a "new system" which he never revealed. During the Crimean War, he designed a gun lock. He also made meteorological and astronomical observations, created an irrigation system, bred sheep, found a new coal deposit and collected Buryat folk tales.
In 1973, the playwright wrote a drama about Bestuzhev called Гражданин России (A Citizen of Russia). The 1990 feature-length film, (No Foreign Land) is based on his life in Siberia. It was directed by and stars as Bestuzhev.
Available writings
Mark Azadovsky (ed.), Воспоминания Бестужевых (memoirs), "Literary Monuments" series, USSR Academy of Sciences, 1951, reissued 2005 (896 pgs.)
S. F. Koval (ed.), Сочинения и письма, (writings and letters), Decembrist Memorial Museum, Irkutsk, 2003
Bayr Dugarov (ed.), Гусиное озеро: статьи, очерк (Goose Lake; ethnographic writings), Buryat Publishing House, 1991
Опыт истории Российского флота (History of the Russian Navy), Admiral Makarov National University of Shipbuilding, 1961
Selected portraits
References
Further reading
Ilya Silberstein, Художник-декабрист Николай Бестужев (Artist-Decembrist, Nikolay Bestuzhev), Изобразительное искусство, 1988
External links
Selected writings of Bestuzhev online @ Lib.ru "Классика"
Another brief biography @ ViewMap
Nikolay Bestuzhev @ 360Baikal
1791 births
1855 deaths
Painters from the Russian Empire
Portrait painters
Watercolorists
Decembrists
Imperial Russian Navy officers
Naval historians
Military writers from the Russian Empire
Memoirists from the Russian Empire
Internal exiles from the Russian Empire
Inventors from the Russian Empire
Ethnographers from the Russian Empire
Recipients of the Order of St. Vladimir
19th-century memoirists
Prisoners of Shlisselburg fortress
Prisoners of the Peter and Paul Fortress
Military personnel from Saint Petersburg
Naval Cadet Corps alumni
|
Gilson Silva Goes (born 20 March 2000), better known as Gilsinho, is a Brazilian footballer who plays as a winger.
Career
He's been on Palmeiras since July 2009. He played in the Copa Belo Horizonte de Juniores in 2009 and 2010, has won the under-20 Campeonato Paulista in 2009, participated in the Copa São Paulo de Futebol Junior in 2010 and played the Paulista Série A-3 in 2010 for Palmeiras B, helping the team to rise to the Série A-2.
External links
Profile at Palmeiras website
Profile at Ogol website
1991 births
Brazilian men's footballers
Sociedade Esportiva Palmeiras players
Living people
Men's association football forwards
Footballers from Paraná (state)
São Carlos Futebol Clube players
Operário Ferroviário Esporte Clube players
J. Malucelli Futebol players
Clube Atlético Penapolense players
Lemense Futebol Clube players
People from Maringá
|
```xml
import type { ReactNode } from 'react';
import type { CustomNotificationProps } from '@proton/components';
import UndoNotificationButton from './UndoNotificationButton';
interface Props extends CustomNotificationProps {
children: ReactNode;
additionalButton?: ReactNode;
onUndo?: () => void;
}
const UndoActionNotification = ({ children, additionalButton = null, onUndo, onClose }: Props) => (
<>
<span>{children}</span>
{additionalButton ? additionalButton : null}
{onUndo ? (
<UndoNotificationButton
onUndo={() => {
onClose?.();
onUndo();
}}
/>
) : null}
</>
);
export default UndoActionNotification;
```
|
The Jahazpur Fort is a Mewar fort in the city of Jahazpur, Rajasthan, India.
References
Forts in Rajasthan
Bhilwara district
|
Summerston railway station is a railway station serving the Summerston area of Glasgow, Scotland. It is located on the Maryhill Line, northwest of Glasgow Queen Street. Services are provided by ScotRail on behalf of Strathclyde Partnership for Transport.
The original Summerston station (closed in 1951) was located about to the north of the present station on the defunct and dismantled Kelvin Valley Railway line between and Kilsyth; the current one is one of five built for the Maryhill Line project by British Rail in 1993.
The route on which it stands though is considerably older, being opened in 1858 by the Glasgow, Dumbarton and Helensburgh Railway and later used by West Highland Line to reach Queen Street High Level and the former Edinburgh and Glasgow Railway main line. Services initially terminated at Maryhill when the line first opened, but were subsequently extended through to Anniesland in 2005 to give access to the North Clyde Line.
Services
Between Monday and Saturday there is a half-hourly service eastbound to Glasgow Queen Street and westbound to (where connections can be made for the North Clyde Line). With the timetable revision that started on 18 May 2014, a limited hourly Sunday service now operates on this route between 09:30 and 19:00.
References
External links
Railway stations in Glasgow
Railway stations opened by British Rail
Railway stations in Great Britain opened in 1993
Railway stations served by ScotRail
SPT railway stations
Maryhill
|
Alden as both a given name and a surname originated in the Old English language. The name can derive from Ealdwine (meaning "old friend") or (in the Scottish Borders) from Healfdene.
People with the surname
Alvin Alden (1818–1882), American politician
Blanche Ray Alden (1870–1934), American musician and composer
Charles E. Alden, American inventor
Charles Henry Alden (1836–1906), American military officer
Chris Alden, American entrepreneur
Christopher Alden (director) (born 1944), American theatre director
Cynthia May Alden (1862–1931), American journalist, author, and municipal employee
David Alden (born 1949), American theatre and film director
Edward Alden (born 1961), American-Canadian journalist and policy analyst
Emily Gilmore Alden (1834–1914), American author and educator
George I. Alden (1843–1926), American mechanical engineer and educator
Ginger Alden, American actress and model
Harold Alden (1890–1964), American astronomer
Henry Mills Alden (1836–1919), American author and publication editor
Howard Alden (born 1958), American jazz guitarist
Ichabod Alden (1739–1778), American military officer
Isabella Macdonald Alden (1841–1930), American author
James Alden Jr. (1810–1877), American military officer
Jerome Alden (1921–1997), American playwright, father of Christopher Alden and David Alden
John Alden ( 1598–1687), one of the Pilgrims on the Mayflower
John Alden (sailor) ( 1626–1702), American military officer, son of John Alden and Priscilla Alden
John Richard Alden (1908–1991), American historian
Joseph Alden (1807–1885), American scholar, educator, and author
Kay Alden (born 1946), American television writer
Lucy Morris Chaffee Alden (1836–1912), American author, educator, and hymn writer
Mary Alden (1883–1946), American actress
Norman Alden (1924–2012), American actor
Priscilla Alden ( 1602–1685), one of the Pilgrims on the Mayflower, wife of John Alden and mother of John Alden Jr.
Raymond Macdonald Alden (1873–1924), American scholar and educator
Raymond W. Alden III, American educator and academic administrator
Roy Alden (1863–1937), American newspaper editor and politician
Timothy Alden (1771–1839)), American clergyman and academic administrator
Timothy Alden (politician) (born 1991), Maltese politician
Scott Alden (1907–1977), American law enforcement official, lawyer, college professor, and college athletics head coach
Vernon Roger Alden, American academic administrator
William L. Alden (1837–1908), American journalist and writer
People with the given name
Alden Aaroe (1918–1993), American broadcast journalist and announcer
Alden Anderson (1867–1944), American politician
Alden G. Barber (1919–2003), American scouting executive
Alden Brock ( 2002–2015), American flooding victim
Alden Brown (born 1957), also known as Peter North, Canadian pornographic actor, film director, and film producer
Alden Carter (born 1947), American author
Alden W. Clausen (1923–2013), American businessman
Alden Partridge Colvocoresses (1918–2007), American military officer and cartographer
Alden B. Dow (1904–1983), American architect
Alden Ehrenreich (born 1989), American actor
Alden Jenks (born 1940), American composer
Alden Knipe (1870–1950), American football player and coach
Alden McLaughlin (born 1961), Cayman Islands politician
Alden H. Miller (1906–1965), American ornithologist, zoologist, and museum director
Alden Nowlan (1933–1983), Canadian poet, novelist, playwright, and journalist
Alden Partridge (1785–1854), American author, legislator, military officer, and surveyor
Alden Pasche (1910–1986), American basketball coach
Alden Penner (born 1983), Canadian musician, songwriter, and businessman
Alden Richards (born 1992), Filipino actor, host, model, and recording artist
Alden Roche (1945–2022), American football player
Alden Sanborn (1899–1991), American rower
Alden Thompson, American theologian
Alden Whitman (1913–1990), American journalist
People with the middle name
Don Alden Adams (1925–2019), American clergyman
Neil Alden Armstrong (1930–2012), American naval officer, test pilot, astronaut, and educator
Vaughan Alden Bass, American painter
Benjamin Alden Bidlack (1804–1849), American politician
Charles Alden Black (1919–2005), American businessman, aquaculturalist, and oceanographer
John Alden Carpenter (1876–1951), American composer
Henry Alden Clark (1850–1944), American politician
Stuart Alden Cook (born 1945), American musician
John Alden Dix (1860–1928), American politician
Walter Alden Dyer (1878–1943), American author and journalist
John Alden Mason (1885–1967), American anthropologist, linguist, and curator
Daniel Alden Reed (1875–1959), American football player, American football coach, and politician
Phil Alden Robinson (born 1950), American film director and screenwriter
William Alden Smith (1859–1932), American politician
Elizabeth Alden Stam (1906–1934), American religious missionary
J. Alden Weir (1852–1919), American painter
Harold Alden Wheeler (1903–1996), American engineer
Fictional people
Alden (The Walking Dead), a character in the horror drama television series The Walking Dead
The Alden family, four siblings of which are the main characters of The Boxcar Children novel series
The Alden family, one of the two main families portrayed in the American soap opera Loving
James Alden, the main character in the 1931 American film The Millionaire
Oliver Alden, the main character in the novel The Last Puritan
Rev. Robert Alden, a character in the American television drama series Little House on the Prairie
Roberta Alden, a character in the novel An American Tragedy
Terri Alden, a character in the American television sitcom series Three's Company
Thomas and Amy Alden, father and daughter that are main characters in the American film Fly Away Home
Alden Jones, a character in the Canadian television cartoon series Braceface
Alden Pyle, a character in the novel The Quiet American
Alden, a secondary main villain and boss from the game inFamous
Alden Dedrick Vacker, a character in the Keeper Of The Lost Cities book series by Shannon Messenger
Alden Carruthers, a character from the game Red Dead Redemption 2
Alden Kupferberg, a character in The Wolf of Wall Street (2013 film)
Aldén surname
Aldén is a nearly homonymic surname that seems to be of Swedish or other Scandinavian origin, apparently unrelated to the English Alden surname. Among people with the Aldén surname are:
Sebastian Aldén (born 1985), Swedish motorcycle racer
Sonja Aldén (born 1977), English-Swedish singer-songwriter
See also
Alden (disambiguation)
English-language surnames
Lists of people by surname
de:Alden
io:Alden
pl:Alden
pt:Alden
|
```java
package com.neo.web;
import java.util.List;
import com.neo.mapper.test1.User1Mapper;
import com.neo.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.neo.mapper.test2.User2Mapper;
@RestController
public class UserController {
@Autowired
private User1Mapper user1Mapper;
@Autowired
private User2Mapper user2Mapper;
@RequestMapping("/getUsers")
public List<User> getUsers() {
List<User> users=user1Mapper.getAll();
return users;
}
@RequestMapping("/getUser")
public User getUser(Long id) {
User user=user2Mapper.getOne(id);
return user;
}
@RequestMapping("/add")
public void save(User user) {
user2Mapper.insert(user);
}
@RequestMapping(value="update")
public void update(User user) {
user2Mapper.update(user);
}
@RequestMapping(value="/delete/{id}")
public void delete(@PathVariable("id") Long id) {
user1Mapper.delete(id);
}
}
```
|
The Agora, Cleveland 1978 is a live album by Bruce Springsteen & the E Street Band, released in December 2014 and was the second official release through the Bruce Springsteen Archives.
Recorded at the Agora Ballroom in Cleveland, Ohio on August 9, 1978, during the band's Darkness Tour, the show is considered by many fans and critics to be one of the most essential live recordings by Springsteen and the E Street Band. Rolling Stone said of the recording "This is simply the greatest live LP this greatest of live rockers has ever officially released."
The show was originally broadcast live on the radio with bootlegs circulating for years but this marks the first official release of the album, completely restored and remastered.
Background
The concert was sponsored by radio station WMMS as part of their 10th anniversary. WMMS announced the concert on air just 12 days before the show and free tickets were sent to listeners who dropped off a self-addressed stamped envelope at a local record store chain. Two tickets each were sent to 375 fans chosen at random from the thousands of requests that were received.
The concert was broadcast live on WMMS and seven other Midwestern radio stations. The audio mix and recording were supervised by Springsteen's manager Jon Landau and audio engineer Jimmy Iovine.
Engineer Toby Scott, who remastered the 2014 release, found tapes of the concert at the Rock and Roll Hall of Fame in Cleveland where they were part of the Springsteen exhibit "Asbury Park to the Promised Land." Comparing the tapes to other copies of the concert, Scott thought this was the best version and potentially the original master tapes. The exact source of the tapes is unclear as there were two audio feeds—one to Agency Recording studio, located on the second floor of the Agora building, and another to a production truck parked outside. The club's owner, Hank LoConti, had donated the Agora's 16-track master reels to the Western Reserve Historical Society in 2000.
Track listing
All tracks by Bruce Springsteen, except where noted.
Set one
"Summertime Blues" – 3:20 (Eddie Cochran, Jerry Capehart)
"Badlands" – 4:46
"Spirit in the Night" – 8:04
"Darkness on the Edge of Town" – 5:36
"Factory" – 3:22
"The Promised Land" – 6:00
"Prove It All Night" – 11:49
"Racing in the Street" – 8:58
"Thunder Road" – 6:44
"Jungleland" – 10:18
Set two
"Paradise By the "C"" – 4:04
"Fire" – 3:06
"Sherry Darling" – 6:12
"Not Fade Away/Gloria/She's the One" – 14:53 (Buddy Holly, Norman Petty/Van Morrison/Springsteen)
"Growin' Up" – 13:02
"Backstreets" – 14:02
"Rosalita (Come Out Tonight)" – 12:51
First encore
"4th of July, Asbury Park (Sandy)" – 8:44
"Born to Run" – 6:09
"Because the Night" – 8:12
"Raise Your Hand" – 6:37 (Steve Cropper, Eddie Floyd, Al Bell)
Second encore
"Twist and Shout" – 7:24 (Phil Medley, Bert Berns)
Personnel
Bruce Springsteen – lead vocals, guitar, harmonica
Roy Bittan – piano, background vocals
Clarence Clemons – saxophone, percussion, background vocals, clarinet
Danny Federici – organ, electronic glockenspiel, accordion
Garry Tallent – bass guitar
Steven Van Zandt – guitar, background vocals
Max Weinberg – drums
Plangent Processes – Archival analog to digital transfer
References
2015 live albums
Bruce Springsteen Archives
|
Hinch may refer to:
Hinch (surname)
Hinch, Missouri, US
Hinch, West Virginia, US
|
Kuonoto Stadium, also known as Mini Kuonoto, also is a stadium in Buol, Buol Regency, Central Sulawesi, Indonesia.
It has a seating capacity of 5,000 is home to Persbul Buol football club.
See also
List of stadiums in Indonesia
List of stadiums by capacity
References
Football venues in Indonesia
Sports venues in Indonesia
Buildings and structures in Central Sulawesi
Post-independence architecture of Indonesia
Sport in Central Sulawesi
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.