blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 3 264 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 5 140 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 986
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 3.89k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 23
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 145
values | src_encoding stringclasses 34
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 3 10.4M | extension stringclasses 122
values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
727e779661fbeb7c31dddb21354a78205a985029 | aad58a8df5c485f01b950ccc55efbdf0efcfc3cc | /ScreenOled2.ino | b71aad74f825f32bec655b244ce9554a704c0167 | [] | no_license | aboillet/photontest | 5bf05436eb1390a754750864df49073ec4e45ed4 | dd129f8860a97b752a0fce7cb1c9edf6108666b5 | refs/heads/master | 2021-01-23T14:57:30.633667 | 2015-09-07T12:58:53 | 2015-09-07T12:58:53 | 41,286,626 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,240 | ino | /*
This is an example for our Monochrome OLEDs based on SSD1306 drivers
Pick one up today in the adafruit shop!
------> http://www.adafruit.com/category/63_98
This example is for a 128x64 size display using SPI to communicate
4 or 5 pins are required to interface
Adafruit invests time and resources providing this open source code,
please support Adafruit and open-source hardware by purchasing
products from Adafruit!
Written by Limor Fried/Ladyada for Adafruit Industries.
BSD license, check license.txt for more information
All text above, and the splash screen must be included in any redistribution
*********************************************************************/
#include "Adafruit_GFX.h"
#include "Adafruit_SSD1306.h"
#include "OneWire.h"
/* Uncomment this block to use hardware SPI
// If using software SPI (the default case):
#define OLED_MOSI A5 //D1
#define OLED_CLK A3 //D0
#define OLED_DC D2
#define OLED_CS D3
#define OLED_RESET D4
Adafruit_SSD1306 display(OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);
*/
/* use hardware SPI, wiring:
[SCRN -> PHTN]
CS -> A2
DC -> D3
RST -> D5
D1 -> A5
D0 -> A3
VCC -> 3V3
GND -> GND
*/
#define OLED_DC D3
#define OLED_CS A2
#define OLED_RESET D5
Adafruit_SSD1306 display(OLED_DC, OLED_RESET, OLED_CS);
// Define the pins we will use
int ow = D0; // put the onewire bus on D0
OneWire ds(ow); // a 1 - 4.7K resistor to 3.3v is necessary
float celsius, temp, fahrenheit;
int CelsiusUnit, CelsiusDecim;
double sparkcelsius;
String text;
void setup() {
//Serial.begin(9600);
Serial.begin(57600); // local hardware test only onewire
// by default, we'll generate the high voltage from the 3.3v line internally! (neat!)
display.begin(SSD1306_SWITCHCAPVCC);
// init done
/* display.display(); // show splashscreen
delay(2000);*/
display.clearDisplay();
display.display();
Spark.variable("temperature", &sparkcelsius, DOUBLE);
}
void loop() {
byte i;
byte present = 0;
byte type_s;
byte data[12];
byte addr[8];
if ( !ds.search(addr)) {
Serial.println("No more addresses.");
Serial.println();
ds.reset_search();
delay(250);
return;
}
Serial.print("ROM =");
for( i = 0; i < 8; i++) {
Serial.write(' ');
Serial.print(addr[i], HEX);
}
if (OneWire::crc8(addr, 7) != addr[7]) {
Serial.println("CRC is not valid!");
return;
}
Serial.println();
// the first ROM byte indicates which chip
// includes debug output of chip type
switch (addr[0]) {
case 0x10:
Serial.println(" Chip = DS18S20"); // or old DS1820
type_s = 1;
break;
case 0x28:
Serial.println(" Chip = DS18B20");
type_s = 0;
break;
case 0x22:
Serial.println(" Chip = DS1822");
type_s = 0;
break;
case 0x26:
Serial.println(" Chip = DS2438");
type_s = 2;
break;
default:
Serial.println("Device is not a DS18x20/DS1822/DS2438 device. Skipping...");
return;
}
ds.reset();
ds.select(addr); // Just do one at a time for testing
// change to skip if you already have a list of addresses
// then loop through them below for reading
ds.write(0x44); // start conversion, with parasite power on at the end
delay(900); // maybe 750ms is enough, maybe not, I'm shooting for 1 reading per second
// prob should set to min reliable and check the timer for 1 second intervals
// but that's a little fancy for test code
// we might do a ds.depower() here, but the reset will take care of it.
present = ds.reset();
ds.select(addr);
ds.write(0xBE, 0); // Read Scratchpad 0
Serial.print(" Data = ");
Serial.print(present, HEX);
Serial.print(" ");
for ( i = 0; i < 9; i++) { // we need 9 bytes
data[i] = ds.read();
Serial.print(data[i], HEX);
Serial.print(" ");
}
Serial.print(" CRC=");
Serial.print(OneWire::crc8(data, 8), HEX);
Serial.println();
// Convert the data to actual temperature
// because the result is a 16 bit signed integer, it should
// be stored to an "int16_t" type, which is always 16 bits
// even when compiled on a 32 bit processor.
int16_t raw = (data[1] << 8) | data[0];
if (type_s) {
if (type_s==1) { // DS18S20
raw = raw << 3; // 9 bit resolution default
if (data[7] == 0x10) {
// "count remain" gives full 12 bit resolution
raw = (raw & 0xFFF0) + 12 - data[6];
}
celsius = (float)raw / 16.0;
}else{ // type_s==2 for DS2438
if (data[2] > 127) data[2]=0;
data[1] = data[1] >> 3;
celsius = (float)data[2] + ((float)data[1] * .03125);
}
} else { // DS18B20 and DS1822
byte cfg = (data[4] & 0x60);
// at lower res, the low bits are undefined, so let's zero them
if (cfg == 0x00) raw = raw & ~7; // 9 bit resolution, 93.75 ms
else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
//// default is 12 bit resolution, 750 ms conversion time
celsius = (float)raw / 16.0;
}
fahrenheit = celsius * 1.8 + 32.0;
// end of test code
// debug output
Serial.print(" Temperature = ");
Serial.print(celsius);
Serial.print(" Celsius, ");
Serial.print(fahrenheit);
Serial.println(" Fahrenheit");
//conversion des données
CelsiusUnit = (int)celsius; //int
temp = (celsius - CelsiusUnit)*100; //float
CelsiusDecim = (int)temp; //int
sparkcelsius = (double)celsius;
// display on screen
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(WHITE);
text = "Température= ";
text += CelsiusUnit;
text += ".";
text += CelsiusDecim;
text += " C";
display.setCursor(0,0);
display.print(text);
display.display();
/*
//print settings
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(WHITE);
//print
text = "Analog: ";
text += Anaread;
display.setCursor(0,0);
display.print(text);
text = "R: ";
text += (int)vtb;
display.setCursor(0,12);
display.print(text);
display.display();
//wait
delay(100);*/
}
| [
"antoine.boillet@gmail.com"
] | antoine.boillet@gmail.com |
1947b61952b96321ae180eee1a56ba9f5cd85e4a | 756953bd7487da84962013ed4efc19a5ed2561a5 | /src/LuaIntf/impl/CppObject.h | e8409cb72bc27ba835cfef56a891b975abe5872b | [] | no_license | Dummiesman/mm2hook | a4ade067fdc981ea4accde5dbfeb7653b2b5247f | 511c96a24b88f3210791dd8ea668fb377b02c4f5 | refs/heads/master | 2023-08-19T05:39:17.219544 | 2023-08-10T15:32:00 | 2023-08-10T15:32:00 | 93,969,666 | 2 | 0 | null | 2017-06-10T22:53:27 | 2017-06-10T22:53:27 | null | UTF-8 | C++ | false | false | 17,196 | h | //
// https://github.com/SteveKChiu/lua-intf
//
// Copyright 2014, Steve K. Chiu <steve.k.chiu@gmail.com>
//
// The MIT License (http://www.opensource.org/licenses/mit-license.php)
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
template <typename T, int KIND = 0>
struct CppSignature
{
/**
* Get the signature id for type
*
* The id is unique in the process
*/
static void* value()
{
static bool v = false;
return &v;
}
};
template <typename T>
using CppClassSignature = CppSignature<T, 1>;
template <typename T>
using CppConstSignature = CppSignature<T, 2>;
//--------------------------------------------------------------------------
/**
* Because of Lua's dynamic typing and our improvised system of imposing C++
* class structure, there is the possibility that executing scripts may
* knowingly or unknowingly cause invalid data to get passed to the C functions
* created by LuaIntf. To improve type security, we have the following policy:
*
* 1. Scripts cannot set the metatable on a userdata
* 2. CppObject's metatable has been tagged by typeid
* 3. CppObject's typeid is a unique pointer in the process.
* 4. Access to CppObject class method will check for typeid, and raise error if not matched
*/
class CppObject
{
protected:
CppObject() {}
template <typename OBJ>
static void* allocate(lua_State* L, void* class_id)
{
void* mem = lua_newuserdata(L, sizeof(OBJ));
lua_rawgetp(L, LUA_REGISTRYINDEX, class_id);
luaL_checktype(L, -1, LUA_TTABLE);
lua_setmetatable(L, -2);
return mem;
}
public:
virtual ~CppObject() {}
CppObject(const CppObject&) = delete;
CppObject& operator = (const CppObject&) = delete;
/**
* Whether the object is shared pointer
*/
virtual bool isSharedPtr() const
{
return false;
}
/**
* The object pointer
*/
virtual void* objectPtr() = 0;
/**
* Get internal class id of the given class
*/
template <typename T>
static void* getClassID(bool is_const)
{
return is_const ? CppConstSignature<T>::value() : CppClassSignature<T>::value();
}
/**
* Returns the CppObject* if the class on the Lua stack is exact the same class (not one of the subclass).
* If the class does not match, a Lua error is raised.
*/
template <typename T>
static CppObject* getExactObject(lua_State* L, int index, bool is_const)
{
return getObject(L, index, getClassID<T>(is_const), is_const, true, true);
}
/**
* Returns the CppObject* if the object on the Lua stack is an instance of the given class.
* If the object is not the class or a subclass, a Lua error is raised.
*/
template <typename T>
static CppObject* getObject(lua_State* L, int index, bool is_const)
{
return getObject(L, index, getClassID<T>(is_const), is_const, false, true);
}
/**
* Get a pointer to the class from the Lua stack.
*
* If the object is not the class or a subclass, return nullptr.
*/
template <typename T>
static T* cast(lua_State* L, int index, bool is_const)
{
CppObject* object = getObject(L, index, getClassID<T>(is_const), is_const, false, false);
return object ? static_cast<T*>(object->objectPtr()) : nullptr;
}
/**
* Get a pointer to the class from the Lua stack.
*
* If the object is not the class or a subclass, a Lua error is raised.
*/
template <typename T>
static T* get(lua_State* L, int index, bool is_const)
{
return static_cast<T*>(getObject<T>(L, index, is_const)->objectPtr());
}
private:
static void typeMismatchError(lua_State* L, int index);
static CppObject* getObject(lua_State* L, int index, void* class_id,
bool is_const, bool is_exact, bool raise_error);
};
//----------------------------------------------------------------------------
class CppAutoDowncast
{
#if LUAINTF_AUTO_DOWNCAST
private:
template <typename T, typename SUPER, bool IS_CONST>
static void* tryDowncast(SUPER* obj) {
void* casted = dynamic_cast<T*>(obj);
if (casted == obj) {
return CppObject::getClassID<T>(IS_CONST);
} else {
return nullptr;
}
}
template <typename T, typename SUPER, bool IS_CONST>
static void addDowncast(LuaRef super) {
lua_State* L = super.state();
LuaRef downcast = LuaRef::createUserDataFrom(L, &tryDowncast<T, SUPER, IS_CONST>);
void* class_id = CppObject::getClassID<SUPER>(IS_CONST);
bool* class_may_downcast = static_cast<bool*>(class_id);
*class_may_downcast = true;
LuaRef list = super.rawget("__downcast");
if (list == nullptr) {
list = LuaRef::createTable(L);
super.rawset("__downcast", list);
}
list.rawset(list.rawlen() + 1, downcast);
}
static void* findClassID(lua_State* L, void* obj, void* class_id) {
bool class_may_downcast = *static_cast<bool*>(class_id);
if (!class_may_downcast) return class_id;
// <class_meta>
lua_rawgetp(L, LUA_REGISTRYINDEX, class_id);
luaL_checktype(L, -1, LUA_TTABLE);
// <class_meta> <downcast>
lua_pushliteral(L, "__downcast");
lua_rawget(L, -2);
if (!lua_isnil(L, -1)) {
int len = int(lua_rawlen(L, -1));
for (int i = 1; i <= len; i++) {
// <class_meta> <downcast> <cast_func>
lua_rawgeti(L, -1, i);
auto downcast = *reinterpret_cast<void*(**)(void*)>(lua_touserdata(L, -1));
void* cast_class_id = downcast(obj);
if (cast_class_id) {
lua_pop(L, 3);
return findClassID(L, obj, cast_class_id);
}
lua_pop(L, 1);
}
}
lua_pop(L, 2);
return class_id;
}
public:
template <typename T, typename SUPER>
static void add(lua_State* L) {
LuaRef registry(L, LUA_REGISTRYINDEX);
LuaRef super = registry.rawgetp(CppSignature<SUPER>::value());
addDowncast<T, SUPER, false>(super.rawget("___class"));
addDowncast<T, SUPER, true>(super.rawget("___const"));
}
template <typename T>
static void* getClassID(lua_State* L, T* obj, bool is_const) {
void* class_id = CppObject::getClassID<T>(is_const);
return findClassID(L, obj, class_id);
}
#else
public:
template <typename T>
static void* getClassID(lua_State*, T*, bool is_const) {
return CppObject::getClassID<T>(is_const);
}
#endif
};
//----------------------------------------------------------------------------
/**
* Wraps a class object stored in a Lua userdata.
*
* The lifetime of the object is managed by Lua. The object is constructed
* inside the userdata using placement new.
*/
template <typename T>
class CppObjectValue : public CppObject
{
using ObjectValue = CppObjectValue<T>;
private:
CppObjectValue()
{
if (MAX_PADDING > 0) {
uintptr_t offset = reinterpret_cast<uintptr_t>(&m_data[0]) % alignof(T);
if (offset > 0) offset = alignof(T) - offset;
assert(offset < MAX_PADDING);
m_data[sizeof(m_data) - 1] = static_cast<unsigned char>(offset);
}
}
static ObjectValue* allocateValue(lua_State *L, bool is_const)
{
void* mem = allocate<ObjectValue>(L, getClassID<T>(is_const));
return ::new (mem) ObjectValue();
}
public:
virtual ~CppObjectValue()
{
T* obj = static_cast<T*>(objectPtr());
obj->~T();
}
virtual void* objectPtr() override
{
if (MAX_PADDING == 0) {
return &m_data[0];
} else {
return &m_data[0] + m_data[sizeof(m_data) - 1];
}
}
template <typename... P>
static void pushToStack(lua_State* L, bool is_const, P&&... args)
{
ObjectValue* v = allocateValue(L, is_const);
::new (v->objectPtr()) T(std::forward<P>(args)...);
}
template <typename... P>
static void pushToStack(lua_State* L, std::tuple<P...>& args, bool is_const)
{
ObjectValue* v = allocateValue(L, is_const);
CppInvokeClassConstructor<T>::call(v->objectPtr(), args);
}
static void pushToStack(lua_State* L, const T& obj, bool is_const)
{
ObjectValue* v = allocateValue(L, is_const);
::new (v->objectPtr()) T(obj);
}
private:
using AlignType = typename std::conditional<alignof(T) <= alignof(double), T, void*>::type;
static constexpr int MAX_PADDING = alignof(T) <= alignof(AlignType) ? 0 : alignof(T) - alignof(AlignType) + 1;
alignas(AlignType) unsigned char m_data[sizeof(T) + MAX_PADDING];
};
//----------------------------------------------------------------------------
/**
* Wraps a pointer to a class object inside a Lua userdata.
*
* The lifetime of the object is managed by C++.
*/
class CppObjectPtr : public CppObject
{
private:
explicit CppObjectPtr(void* obj)
: m_ptr(obj)
{
assert(obj != nullptr);
}
public:
virtual void* objectPtr() override
{
return m_ptr;
}
template <typename T>
static void pushToStack(lua_State* L, T* obj, bool is_const)
{
void* mem = allocate<CppObjectPtr>(L, CppAutoDowncast::getClassID(L, obj, is_const));
::new (mem) CppObjectPtr(obj);
}
private:
void* m_ptr;
};
//----------------------------------------------------------------------------
/**
* Wraps a shared ptr that references a class object.
*
* The template argument SP is the smart pointer type
*/
template <typename SP, typename T>
class CppObjectSharedPtr : public CppObject
{
private:
explicit CppObjectSharedPtr(T* obj)
: m_sp(obj)
{}
explicit CppObjectSharedPtr(const SP& sp)
: m_sp(sp)
{}
public:
virtual bool isSharedPtr() const override
{
return true;
}
virtual void* objectPtr() override
{
return const_cast<T*>(&*m_sp);
}
SP& sharedPtr()
{
return m_sp;
}
static void pushToStack(lua_State* L, T* obj, bool is_const)
{
void* mem = allocate<CppObjectSharedPtr<SP, T>>(L,
CppAutoDowncast::getClassID(L, obj, is_const));
::new (mem) CppObjectSharedPtr<SP, T>(obj);
}
static void pushToStack(lua_State* L, const SP& sp, bool is_const)
{
void* mem = allocate<CppObjectSharedPtr<SP, T>>(L,
CppAutoDowncast::getClassID(L, const_cast<T*>(&*sp), is_const));
::new (mem) CppObjectSharedPtr<SP, T>(sp);
}
private:
SP m_sp;
};
//----------------------------------------------------------------------------
template <typename T>
struct CppObjectTraits
{
using ObjectType = T;
static constexpr bool isSharedPtr = false;
static constexpr bool isSharedConst = false;
};
#define LUA_USING_SHARED_PTR_TYPE(SP) \
template <typename T> \
struct CppObjectTraits <SP<T>> \
{ \
using ObjectType = typename std::remove_cv<T>::type; \
\
static constexpr bool isSharedPtr = true; \
static constexpr bool isSharedConst = std::is_const<T>::value; \
};
//---------------------------------------------------------------------------
template <typename SP, typename OBJ, bool IS_SHARED, bool IS_REF>
struct LuaCppObjectFactory;
template <typename T>
struct LuaCppObjectFactory <T, T, false, false>
{
static void push(lua_State* L, const T& obj, bool is_const)
{
CppObjectValue<T>::pushToStack(L, obj, is_const);
}
static T& cast(lua_State*, CppObject* obj)
{
return *static_cast<T*>(obj->objectPtr());
}
};
template <typename T>
struct LuaCppObjectFactory <T, T, false, true>
{
static void push(lua_State* L, const T& obj, bool is_const)
{
CppObjectPtr::pushToStack(L, const_cast<T*>(&obj), is_const);
}
static T& cast(lua_State*, CppObject* obj)
{
return *static_cast<T*>(obj->objectPtr());
}
};
template <typename SP, typename T>
struct LuaCppObjectFactory <SP, T, true, true>
{
static void push(lua_State* L, const SP& sp, bool is_const)
{
if (!sp) {
lua_pushnil(L);
} else {
CppObjectSharedPtr<SP, T>::pushToStack(L, sp, is_const);
}
}
static SP& cast(lua_State* L, CppObject* obj)
{
if (!obj->isSharedPtr()) {
luaL_error(L, "is not shared object");
}
return static_cast<CppObjectSharedPtr<SP, T>*>(obj)->sharedPtr();
}
};
//---------------------------------------------------------------------------
/**
* Lua conversion for reference or value to the class type,
* this will catch all C++ class unless LuaTypeMapping<> exists.
*/
template <typename T, bool IS_CONST, bool IS_REF>
struct LuaClassMapping
{
using ObjectTraits = CppObjectTraits<T>;
using ObjectType = typename ObjectTraits::ObjectType;
static constexpr bool isShared = ObjectTraits::isSharedPtr;
static constexpr bool isRef = isShared ? true : IS_REF;
static constexpr bool isConst = isShared ? ObjectTraits::isSharedConst : IS_CONST;
static void push(lua_State* L, const T& t)
{
LuaCppObjectFactory<T, ObjectType, isShared, isRef>::push(L, t, isConst);
}
static T& get(lua_State* L, int index)
{
CppObject* obj = CppObject::getObject<ObjectType>(L, index, isConst);
return LuaCppObjectFactory<T, ObjectType, isShared, isRef>::cast(L, obj);
}
static const T& opt(lua_State* L, int index, const T& def)
{
if (lua_isnoneornil(L, index)) {
return def;
} else {
return get(L, index);
}
}
};
//----------------------------------------------------------------------------
/**
* Lua conversion for pointer to the class type
*/
template <typename T>
struct LuaTypeMapping <T*>
{
using Type = typename std::decay<T>::type;
using PtrType = T*;
static constexpr bool isConst = std::is_const<T>::value;
static void push(lua_State* L, const Type* p)
{
if (p == nullptr) {
lua_pushnil(L);
} else {
CppObjectPtr::pushToStack(L, const_cast<Type*>(p), isConst);
}
}
static PtrType get(lua_State* L, int index)
{
return CppObject::get<Type>(L, index, isConst);
}
static PtrType opt(lua_State* L, int index, PtrType def)
{
if (lua_isnoneornil(L, index)) {
return def;
} else {
return CppObject::get<Type>(L, index, isConst);
}
}
};
//----------------------------------------------------------------------------
namespace Lua
{
/**
* Create new object inside userdata directly and push onto Lua stack.
*/
template <typename T, typename... P>
inline void pushNew(lua_State* L, P&&... args)
{
using Type = typename std::remove_cv<T>::type;
CppObjectValue<Type>::pushToStack(L, std::is_const<T>::value, std::forward<P>(args)...);
}
/**
* Cast stack value at the index to the given class, return nullptr if it is not.
*/
template <typename T>
inline T* objectCast(lua_State* L, int index)
{
using Type = typename std::remove_cv<T>::type;
return CppObject::cast<Type>(L, index, std::is_const<T>::value);
}
/**
* Cast LuaRef to the given class, return nullptr if it is not.
*/
template <typename T>
inline T* objectCast(const LuaRef& ref)
{
ref.pushToStack();
T* object = objectCast<T>(ref.state(), -1);
lua_pop(ref.state(), 1);
return object;
}
}
/**
* Create LuaRef for cpp class, the object is created inside userdata directly.
*/
template <typename T, typename... P>
inline LuaRef LuaRefObject(lua_State* L, P&&... args)
{
Lua::pushNew<T>(L, std::forward<P>(args)...);
return LuaRef::popFromStack(L);
}
| [
"mk.ludwig1@gmail.com"
] | mk.ludwig1@gmail.com |
a8015626f060d97f691143aed0fa9e8c67db8cb4 | ae47a1672c9b3b3c3b66451b2f01b8559ec3357a | /lib/src/facts/fact.cc | 9f7d37afe92df0fa2b973f557103234aaeebb420 | [
"Apache-2.0"
] | permissive | RagnarDanneskjold/cfacter | 45b007a8db6bdbb39470a92177daa74ead0aed51 | 20259bc26029b5ee9a4ab54dadf6c04b362f8856 | refs/heads/master | 2020-12-25T13:12:53.921762 | 2014-07-22T17:13:52 | 2014-07-22T17:13:52 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 345 | cc | #include <facter/version.h>
#include <facter/facts/collection.hpp>
#include <facter/facts/scalar_value.hpp>
using namespace std;
namespace facter { namespace facts {
void populate_common_facts(collection& facts)
{
facts.add("cfacterversion", make_value<string_value>(LIBFACTER_VERSION));
}
}} // namespace facter::facts
| [
"peter.huene@puppetlabs.com"
] | peter.huene@puppetlabs.com |
da52e50da2b20ee357a25dbc01cc2df99fb002e9 | 5d8b7f15ca6a8fefdb891ca6ff6aeed6aa6a00bb | /LaboratorioPila/LaboratorioPila/ElementoDouble.h | 42dfa23169f9b02baf7ac434979b425cda58e8e9 | [] | no_license | Xbulldcm/LaboratorioPila | 6f2c70b5a513171541727909091870a1b43a4897 | 3870cae9c70e71d47b0065d767365793dcfb3a1c | refs/heads/master | 2021-01-10T21:03:50.040847 | 2015-06-04T07:05:15 | 2015-06-04T07:05:15 | 36,852,823 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 393 | h | /*
* ElementoDouble.h
*
* Created on: May 8, 2015
* Author: b11555
*/
#ifndef ELEMENTODOUBLE_H_
#define ELEMENTODOUBLE_H_
#include "Elemento.h"
using namespace std;
class ElementoDouble : public Elemento {
private:
double d;
public:
ElementoDouble(double d);
~ElementoDouble();
int compareTo(Elemento *);
void imprimir(ostream &) const;
};
#endif /* ELEMENTODOUBLE_H_ */
| [
"dcm2311@gmail.com"
] | dcm2311@gmail.com |
a8b614143c247de9c0b125785a204f7dbe74d6aa | 4489e19d2f55ad685290616966b248caf58a3495 | /virtual.cpp | b55f614b35765475b40b44fb8f64e37f20be3c68 | [] | no_license | fkymy/CPPModules | ae0c2c708307c9b64f678f7a56eda48ff2fa9d04 | a5fc2a9d2e2bc277356f8999ab183296bebe9075 | refs/heads/main | 2023-06-06T07:40:31.745437 | 2021-06-26T10:44:43 | 2021-06-26T10:44:43 | 365,246,120 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 359 | cpp | class BaseClass
{
public:
virtual ~BaseClass() {} // Polymorphic classes need virtual destructors
virtual void doSomething();
private:
int baseX, baseY;
};
class DerivedClass: public BaseClass
{
public:
virtual void doSomething(); // Override BaseClass version
private:
int derX, derY;
};
int main() {
return sizeof(DerivedClass);
}
| [
"yuskefuku@gmail.com"
] | yuskefuku@gmail.com |
f50a8b27deb8b3190b410babd491c16eb28bf4e3 | 7f8b5850d5ff2c8cf3f47aec67eb67ae9ea4d553 | /src/modules/SX126x/SX1268.h | 5a1453d22a8e4d7266d722ae3336882d124a9257 | [
"MIT"
] | permissive | BarryPSmith/RadioLib | 1eb51f4253ba41c1744cf5d7c023138c9280f605 | 4032aac9443a6b59437ab47cd5266f3971d1f991 | refs/heads/master | 2022-01-25T12:57:14.651572 | 2019-12-02T05:03:55 | 2019-12-02T05:03:55 | 220,471,305 | 0 | 0 | MIT | 2019-11-12T21:05:33 | 2019-11-08T13:21:27 | C++ | UTF-8 | C++ | false | false | 3,204 | h | #ifndef _RADIOLIB_SX1268_H
#define _RADIOLIB_SX1268_H
#include "../../TypeDef.h"
#include "../../Module.h"
#include "SX126x.h"
//SX126X_CMD_SET_PA_CONFIG
#define SX126X_PA_CONFIG_SX1268 0x00
/*!
\class SX1268
\brief Derived class for %SX1268 modules.
*/
class SX1268: public SX126x {
public:
/*!
\brief Default constructor.
\param mod Instance of Module that will be used to communicate with the radio.
*/
SX1268(Module* mod);
// basic methods
/*!
\brief Initialization method for LoRa modem.
\param freq Carrier frequency in MHz. Defaults to 434.0 MHz.
\param bw LoRa bandwidth in kHz. Defaults to 125.0 kHz.
\param sf LoRa spreading factor. Defaults to 9.
\param cr LoRa coding rate denominator. Defaults to 7 (coding rate 4/7).
\param syncWord 2-byte LoRa sync word. Defaults to SX126X_SYNC_WORD_PRIVATE (0x1424).
\param power Output power in dBm. Defaults to 14 dBm.
\param currentLimit Current protection limit in mA. Defaults to 60.0 mA.
\param preambleLength LoRa preamble length in symbols. Defaults to 8 symbols.
\param tcxoVoltage TCXO reference voltage to be set on DIO3. Defaults to 1.6 V, set to 0 to skip.
\returns \ref status_codes
*/
int16_t begin(float freq = 434.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint16_t syncWord = SX126X_SYNC_WORD_PRIVATE, int8_t power = 14, float currentLimit = 60.0, uint16_t preambleLength = 8, float tcxoVoltage = 1.6);
/*!
\brief Initialization method for FSK modem.
\param freq Carrier frequency in MHz. Defaults to 434.0 MHz.
\param br FSK bit rate in kbps. Defaults to 48.0 kbps.
\param freqDev Frequency deviation from carrier frequency in kHz. Defaults to 50.0 kHz.
\param rxBw Receiver bandwidth in kHz. Defaults to 156.2 kHz.
\param power Output power in dBm. Defaults to 14 dBm.
\param currentLimit Current protection limit in mA. Defaults to 60.0 mA.
\parma preambleLength FSK preamble length in bits. Defaults to 16 bits.
\param dataShaping Time-bandwidth product of the Gaussian filter to be used for shaping. Defaults to 0.5.
\param tcxoVoltage TCXO reference voltage to be set on DIO3. Defaults to 1.6 V, set to 0 to skip.
\returns \ref status_codes
*/
int16_t beginFSK(float freq = 434.0, float br = 48.0, float freqDev = 50.0, float rxBw = 156.2, int8_t power = 14, float currentLimit = 60.0, uint16_t preambleLength = 16, float dataShaping = 0.5, float tcxoVoltage = 1.6);
// configuration methods
/*!
\brief Sets carrier frequency. Allowed values are in range from 150.0 to 960.0 MHz.
\param freq Carrier frequency to be set in MHz.
\param calibrate Run image calibration.
\returns \ref status_codes
*/
int16_t setFrequency(float freq, bool calibrate = true);
/*!
\brief Sets output power. Allowed values are in range from -17 to 22 dBm.
\param power Output power to be set in dBm.
\returns \ref status_codes
*/
int16_t setOutputPower(int8_t power);
#ifndef RADIOLIB_GODMODE
private:
#endif
};
#endif
| [
"jgromes@users.noreply.github.com"
] | jgromes@users.noreply.github.com |
e483c68a6257192d72b619e8b37211a1074ecaec | 53525eb9d3ed764bfee093701abcd659be392022 | /quiz1.2/l.cpp | 727ebcf03f79e3e4dae346e9976d09b2831a5a98 | [] | no_license | derbess/PP1-assist | 078f36370443ad127c75909235d89ded2c611675 | 821eec271a2a7aa6a70749e16294ac99325e18bd | refs/heads/master | 2023-02-26T07:48:19.366360 | 2021-02-04T10:51:48 | 2021-02-04T10:51:48 | 335,924,297 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 232 | cpp | #include<iostream>
#include<cmath>
using namespace std;
int main()
{
int n;
cin>>n;
int hh = n/3600; // 4000 1
int mm = (n%3600)/60; // 400 6
int ss = n%60;
cout<<hh<<":"<<mm<<":"<<ss;
return 0;
}
| [
"uderbes@gmail.com"
] | uderbes@gmail.com |
2324f06cb626061845b455d271c349179ecb855b | 059a0e5f9d354799102f7f203e2cab029c528bd9 | /src/apps/TestApp.cpp | a1f970345b1a76693c66b841638547346e09f684 | [] | no_license | alexgg-developer/vulkan_dod_framework | 6e0770708118f3692f06ea5ceb0e110d5fd9770a | 2bacd341aea0bf724254099c826892d82b24b9e9 | refs/heads/master | 2020-09-01T00:50:37.026708 | 2020-05-11T07:37:55 | 2020-05-11T07:37:55 | 218,832,636 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,311 | cpp | #include "TestApp.h"
#include <vector>
#include <assert.h>
#include <iostream>
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtx/string_cast.hpp>
using namespace dodf;
void TestApp::run()
{
//testMemory();
size_t initSize = 33554432;
MemoryPool::Initialize(initSize);
movementComponentManager.allocate(100);
testMovementComponent();
mainLoop();
}
void TestApp::update(float dt)
{
updateTestMovementComponent(dt);
}
void TestApp::draw()
{
}
void TestApp::updateTestMovementComponent(float dt)
{
/*for (const auto & entity : entities) {
movementComponentManager.addPosition(movementComponentManager.lookup(entity), glm::vec3(1.0f, 0.0f, 0.0f));
auto position = movementComponentManager.getPosition(movementComponentManager.lookup(entity));
std::cout << "new position:" << position.x << std::endl;
}*/
movementSystem.simulate(movementComponentManager.getVelocities(), movementComponentManager.getPositions(), movementComponentManager.getSize(), dt);
for (const auto & entity : entities) {
auto position = movementComponentManager.getPosition(movementComponentManager.lookup(entity));
std::cout << "new position:" << glm::to_string(position) << std::endl;
}
}
void TestApp::testMovementComponent()
{
entities.emplace_back(entityManager.create());
movementComponentManager.add(entities[entities.size()-1]);
movementComponentManager.setPosition(movementComponentManager.lookup(entities[entities.size() - 1]), glm::vec3(1.0f, 1.0f, 1.0f));
movementComponentManager.setVelocity(movementComponentManager.lookup(entities[entities.size() - 1]), glm::vec3(0.1f, 0.25f, -0.1f));
}
void TestApp::testMemory()
{
vector<int*> serie(1000);
auto totalSerieSize = 0;
for (auto i = 1; i <= serie.size(); ++i) {
for (auto j = 1; j <= i; ++j) {
++totalSerieSize;
}
}
++totalSerieSize;
MemoryPool::Initialize(totalSerieSize * sizeof(int) * 10);
for (auto i = 1; i <= serie.size(); ++i) {
//serie.push_back(reinterpret_cast<int*>(MemoryPool::Get(i * sizeof(int))));
auto currentSize = MemoryPool::Debug::GetCurrentSize();
auto currentAddress = MemoryPool::Debug::GetCurrentAddress();
auto sizeAsked = i * sizeof(int);
auto newArray = reinterpret_cast<int*>(MemoryPool::Get(sizeAsked));
auto afterGetSize = MemoryPool::Debug::GetCurrentSize();
auto afterGetAddress = MemoryPool::Debug::GetCurrentAddress();
/*cout << "currentSize:: " << currentSize << endl;
cout << "sizeAsked:: " << sizeAsked << endl;
cout << "currentAddress:: " << currentAddress << endl;
//cout << "afterGetSize:: " << afterGetSize << endl;
//cout << "afterGetAddress:: " << afterGetAddress << endl;
cout << "diffSize:: " << afterGetSize - currentSize << endl;
cout << "diffAddress:: " << afterGetAddress - currentAddress << endl;*/
cout << endl;
serie[i-1] = newArray;
auto last = serie[i-1];
for (auto j = 1; j <= i; ++j) {
*last = j;
--totalSerieSize;
//cout << "currentAddress:: " << reinterpret_cast<uintptr_t>(last) << endl;
++last;
}
cout << endl;
}
cout << "run" << endl;
for (auto i = 1; i <= serie.size(); ++i) {
auto current = serie[i - 1];
cout << "current array " << i << endl;
for (auto j = 1; j <= i; ++j) {
assert(*current == j);
cout << "::" << *current << "::" ;
++current;
}
cout << endl;
}
MemoryPool::Destroy();
}
| [
"alexgg.developer@gmail.com"
] | alexgg.developer@gmail.com |
d3ab5b001f5b01e72df9aab0a03ffdddaaaccc9a | 5ed573724846fb350964cc3950cb9e93efbf6c22 | /Routing/tema4.cpp | b2935f34fc5bead12cb02a874b3053fd30460c42 | [] | no_license | zouwen198317/MyProjects | 571729c431ef819b9ce4c2bf7603beadc035e222 | 9e96269f5c45208f08e7f0224f9980be92d291a0 | refs/heads/master | 2021-01-21T12:06:39.892506 | 2015-01-24T21:22:29 | 2015-01-24T21:22:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,750 | cpp | #include "tema4.h"
/* ========================================================================== */
int main( int argc, char *argv[]) {
int numtasks, parinte = NONE, rank, destination, tag = 1;
char inmsg, outmsg = 'x', buf[1401];
MPI_Status Stat;
std::vector<int> tokens;
Messages message;
std::string recv;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int graph[numtasks][numtasks];
int buffer[numtasks][numtasks];
int detour[numtasks];
int **graph_aux = alloc(numtasks);
/* citire din fisier */
for (int i = 0; i < numtasks; i++) {
for (int j = 0; j < numtasks; j++) {
graph[i][j] = 0;
}
}
/* fiecare nod isi citeste propria linie din fisier */
tokens = read_topology(rank, numtasks, argv[1]);
for (unsigned int i = 1; i < tokens.size(); i++) {
graph[rank][tokens[i]] = 1;
}
/* ========================================================================== */
if (rank == MASTER) {
int vecini = 0;
/* se trimit sondaje vecinilor */
for (int i = 0; i < numtasks; i++) {
if (graph[rank][i] == 1) {
MPI_Send(&outmsg, 1, MPI_CHAR, i, tag, MPI_COMM_WORLD);
vecini++;
}
}
/* se primeste matricea de adiacenta de la vecini */
for (int k = 0; k < vecini; k++) {
MPI_Recv(buffer, numtasks*numtasks, MPI_INT,
MPI_ANY_SOURCE, tag, MPI_COMM_WORLD, &Stat);
for (int i = 0; i < numtasks; i++) {
for (int j = 0; j < numtasks; j++) {
graph[i][j] = graph[i][j] || buffer[i][j];
}
}
}
/* se genereaza tabela de routare si se trimite celolalte noduri din graf */
for (int i = 0; i < numtasks; i++) {
for (int j = 0; j < numtasks; j++) {
graph_aux[i][j] = graph[i][j];
}
}
gen_routing_table(graph_aux, rank, detour, numtasks);
write(rank, detour, numtasks);
/* se face broadcast */
for (int i = 1; i < numtasks; i++) {
MPI_Send(graph, numtasks*numtasks, MPI_INT, i, tag, MPI_COMM_WORLD);
}
}
if (rank != MASTER) {
int vecini = 0;
/* se primesc sondaje */
MPI_Recv(&inmsg, 1, MPI_CHAR, MPI_ANY_SOURCE, tag, MPI_COMM_WORLD, &Stat);
parinte = Stat.MPI_SOURCE;
/* se trimit mai departe sondaje vecinilor */
for (int i = 0; i < numtasks; i++) {
if (graph[rank][i] == 1 && i != parinte) {
MPI_Send(&outmsg, 1, MPI_CHAR, i, tag, MPI_COMM_WORLD);
vecini++;
}
}
/* se primesc ecouri de la vecini */
for (int k = 0; k < vecini; k++) {
MPI_Recv(buffer, numtasks*numtasks, MPI_INT,
MPI_ANY_SOURCE, tag, MPI_COMM_WORLD, &Stat);
for (int i = 0; i < numtasks; i++) {
for (int j = 0; j < numtasks; j++) {
graph[i][j] = graph[i][j] || buffer[i][j];
}
}
}
/* se trimit ecouri vecinilor */
MPI_Send(graph, numtasks*numtasks, MPI_INT, parinte, tag, MPI_COMM_WORLD);
/* se primeste matrcea de adiacenta finala */
MPI_Recv(graph, numtasks*numtasks, MPI_INT,
MPI_ANY_SOURCE, tag, MPI_COMM_WORLD, &Stat);
/* se genereaza tabela de routare */
for (int i = 0; i < numtasks; i++) {
for (int j = 0; j < numtasks; j++) {
graph_aux[i][j] = graph[i][j];
}
}
gen_routing_table(graph_aux, rank, detour, numtasks);
write(rank, detour, numtasks);
}
MPI_Barrier(MPI_COMM_WORLD);
/* ========================================================================== */
bool once = true;
int count = 0;
/* se citesc din fisier mesajele de transmis */
tokens = read_messages(rank, argv[2], message);
while (1) {
/* se trimit toate mesajele la destinatiile corespunzatoare */
for (unsigned int i = 0; i < tokens.size(); i++) {
if (tokens[i] != BROADCAST) {
MPI_Send((char *)message[i].c_str(), 1400, MPI_CHAR,
detour[tokens[i]], tag, MPI_COMM_WORLD);
printf("rank = %d, destination = %d, next_hop = %d, message = %s\n",
rank, tokens[i], detour[tokens[i]], get_message(message[i]).c_str());
} else {
MPI_MyBcast(message[i], detour, numtasks);
}
if (i == tokens.size()-1) {
tokens.clear();
}
}
/* daca nu mai exista niciun mesaj de trimis,
se trimit mesaje de terminare la nodul MAASTER */
if (tokens.size() == 0 && once) {
std::string finish;
finish = create_message(rank, MASTER, "AM TERMINAT!");
MPI_Send((char *)finish.c_str(), 1400, MPI_CHAR,
detour[MASTER], tag, MPI_COMM_WORLD);
once = false;
}
/* se primesc toate mesajele */
MPI_Recv(&buf, 1400, MPI_CHAR, MPI_ANY_SOURCE, tag, MPI_COMM_WORLD, &Stat);
recv = buf;
destination = get_destination(recv);
printf("rank = %d, destination = %d, next_hop = %d, message = %s\n",
rank, destination, detour[destination], get_message(recv).c_str());
/* daca mesajul nu a ajuns la destiatie se routeaza mai departe */
if (destination != rank) {
MPI_Send(buf, 1400, MPI_CHAR, detour[destination], tag, MPI_COMM_WORLD);
/* daca mesajul a ajuns la destinatie */
} else {
printf("rank = %d, message = %s, Am ajuns la destinatie!!!\n",
rank, get_message(recv).c_str());
/* daca mesajul este de tipul 'EXIT' nodul care l-a primit trimte
vecinilor mesaje cu acelasi mesaj si isi incheie activitatea */
if (get_message(recv) == "EXIT!") {
std::string finish;
for (int i = 0; i < numtasks; i++) {
if (graph[rank][i] == 1 && i != Stat.MPI_SOURCE) {
finish = create_message(rank, i, "EXIT!");
MPI_Send((char *)finish.c_str(), 1400, MPI_CHAR,
i, tag, MPI_COMM_WORLD);
}
}
break;
}
/* daca nodul MASTER primeste mesaje 'AM TERMINAT', acestea se
contorizeaza pana cand stie ca a primit astfel de mesaje de la
toate celelalte noduri din graf si trimite mesaje cu tipul EXIT */
if (rank == MASTER && get_message(recv) == "AM TERMINAT!") {
count++;
if (count == numtasks) {
std::string finish;
for (int i = 0; i < numtasks; i++) {
if (graph[rank][i] == 1) {
finish = create_message(rank, i, "EXIT!");
MPI_Send((char *)finish.c_str(), 1400, MPI_CHAR,
i, tag, MPI_COMM_WORLD);
}
}
break;
}
}
}
}
MPI_Barrier(MPI_COMM_WORLD);
/* ========================================================================== */
int first, second;
std::vector<int> leader(numtasks), adjunct(numtasks);
once = true;
count = 0;
srand(time(NULL));
while (1) {
/* se trimite la nodul MASTER decizia fiecarui nod */
if (once) {
std::string finish;
std::string message;
first = rand()%numtasks;
while (first == rank) {
first = rand()%numtasks;
}
second = rand()%numtasks;
while (second == first || second == rank) {
second = rand()%numtasks;
}
printf("Rank %d voteaza pentru: leader - %d, adjunct - %d\n",
rank, first, second);
message = int_to_string(first);
message += " " + int_to_string(second);
finish = create_message(rank, MASTER, message);
MPI_Send((char *)finish.c_str(), 1400, MPI_CHAR,
detour[MASTER], tag, MPI_COMM_WORLD);
once = false;
}
/* se realizeaza primirea de mesaje */
MPI_Recv(&buf, 1400, MPI_CHAR, MPI_ANY_SOURCE, tag, MPI_COMM_WORLD, &Stat);
recv = buf;
destination = get_destination(recv);
/* daca mesajul nu a ajuns la destinatie, acesta se routeaza mai departe */
if (destination != rank) {
MPI_Send(buf, 1400, MPI_CHAR, detour[destination], tag, MPI_COMM_WORLD);
/* daca mesajul a ajuns la destinatie... */
} else {
/* daca mesajul este de tipul 'EXIT' nodul care l-a primit trimte
vecinilor mesaje cu acelasi mesaj si isi incheie activitatea */
if (get_message(recv) == "EXIT!") {
std::string finish;
for (int i = 0; i < numtasks; i++) {
if (graph[rank][i] == 1 && i != Stat.MPI_SOURCE) {
finish = create_message(rank, i, "EXIT!");
MPI_Send((char *)finish.c_str(), 1400, MPI_CHAR,
i, tag, MPI_COMM_WORLD);
}
}
break;
}
/* se centralizeaza datele cu votarile fiecarui nod */
if (rank == MASTER) {
std::string finish;
std::string message;
std::pair<int, int> decision;
count++;
if (count != numtasks) {
leader[get_source(get_message(recv))]++;
adjunct[get_destination(get_message(recv))]++;
} else {
leader[get_source(get_message(recv))]++;
adjunct[get_destination(get_message(recv))]++;
decision = get_count(leader, adjunct);
message = int_to_string(decision.first);
message += " " + int_to_string(decision.second);
finish = create_message(rank, MASTER, message);
/* se trimite celorlalte noduri un mesaj cu decizia finala */
MPI_MyBcast(finish, detour, numtasks);
printf("Exit polll!!! Rank %d stie ca: leader - %d, adjunct - %d\n",
rank, first, second);
/* fiecare nod isi incheie activitatea */
for (int i = 0; i < numtasks; i++) {
if (graph[rank][i] == 1) {
finish = create_message(rank, i, "EXIT!");
MPI_Send((char *)finish.c_str(), 1400, MPI_CHAR,
i, tag, MPI_COMM_WORLD);
}
}
break;
}
}
/* se primeste rezultatul final si se afiseaza */
if (rank != MASTER) {
first = get_source(get_message(recv));
second = get_destination(get_message(recv));
printf("Exit polll!!! Rank %d stie ca: leader - %d, adjunct - %d\n",
rank, first, second);
}
}
}
MPI_Finalize();
}
/* ========================================================================== */
| [
"alex@gigiel.(none)"
] | alex@gigiel.(none) |
258533201b1b543a865f5ae799d62c30c6eb3ff3 | e1efe8a7dbf1544565cc1702ea0230537d1be62f | /2018831068/Q2a_Euler.cpp | 16c70f89d5cd5d43e814c45581f6bb1d4627f846 | [] | no_license | Sourav9063/Cpp-All-codes | d99061666b2d40961e458c95d7e436388a351eec | 06369df7b5f7b9a4b091a49a74722ea41761914d | refs/heads/master | 2023-03-08T09:25:18.843800 | 2023-02-06T15:19:29 | 2023-02-06T15:19:29 | 243,684,953 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,964 | cpp | // Name:
#pragma GCC optimize("Ofast")
#pragma GCC optimize ("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include<bits/stdc++.h>
using namespace std;
#define ll long long int //lld
#define ull unsigned long long int //llu
#define pt cout<<"*"<<"\n";
#define nl cout<<"\n";
#define deb(x) cout << #x << "=" << x << "\n";
#define pb(a) emplace_back(a)
#define all(x) (x).begin(),(x).end()
#define rSort(x) sort((x).rbegin(),(x).rend())
#define Sourav ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
//template<typename... T>void read(T&... args) {((cin >> args), ...);}
template <class T>inline void sarray(T* st, T* nd) { while (st < nd)cin >> *st++;/*sf("%d", st++);*/ }
template <class T>inline void parray(T* st, T* nd) { while (st < nd)cout << *st++ << ' ';nl/*sf("%d", st++);*/ }
double f(double x, double y) { return x + y; }
double eulerWithStep(double (*f)(double, double), double y0, double x0, double x1, int n, double* y, double* x)
{
y[0] = y0;
x[0] = x0;
double h = (x1 - x0) / n;
for (int i = 1; i <= n; i++)
{
if (x0 >= x1)break;
x[i] = x[i - 1] + h;
y[i] = y[i - 1] + h * f(x[i - 1], y[i - 1]);
}
return y[n];
}
double eulerWithStepSize(double (*f)(double, double), double y0, double x0, double x1, double h, double* y, double* x)
{
y[0] = y0;
x[0] = x0;
int n = (x1 - x0) / h;
for (int i = 1; i <= n; i++)
{
// if (x0 >= x1)break;
x[i] = x[i - 1] + h;
y[i] = y[i - 1] + h * f(x[i - 1], y[i - 1]);
}
return y[n];
}
int main()
{
// Sourav;
// #ifndef ONLINE_JUDGE
// freopen("C:\\Users\\my_code\\input.in", "r", stdin);
// freopen("C:\\Users\\my_code\\output.in", "w", stdout);
// #endif
double y[100];
double x[100];
cout << eulerWithStep(f, 1, 0, 1, 10, y, x);nl
cout<<eulerWithStepSize(f, 1, 0, 1, 0.1, y, x);nl
// parray(y, y + 10);
return 0;
}
/*
Documentation:
*/ | [
"53114581+Sourav9063@users.noreply.github.com"
] | 53114581+Sourav9063@users.noreply.github.com |
c097857e8d92eb7934da44015db3207e0beeccd9 | 583318dcc75237d74ed25b0394d37299d303c0df | /Macros/2016/Plotting/13TeV/2016/Plotting_PhaseSpaces_2016_FULL/SKTreeValidationDir/SKTreeValidationDoubleEG/MakeDataMCCompPlots.cpp | 1d4e662e40ad02b06d49ae6057f2030eae4b2d6b | [] | no_license | jalmond/LQanalyzer | 7457096ad8a90cb6e7a14e28170338c1de06cdec | 06292f3a4b46e8a00d72025ff968df1b61bc990e | refs/heads/CatAnalyzer_13TeV | 2020-04-04T07:16:53.746743 | 2018-12-07T00:08:37 | 2018-12-07T00:08:37 | 13,470,313 | 1 | 14 | null | 2018-11-12T09:55:34 | 2013-10-10T12:14:06 | C++ | UTF-8 | C++ | false | false | 65,611 | cpp | //// Code makes directory of histograms and cutflow.
#include "MakeDataMCCompPlots.h"
#include "Math/QuantFuncMathCore.h"
#include "TMath.h"
#include "TGraphAsymmErrors.h"
#include "CMS_lumi.h"
int main(int argc, char *argv[]) {
/////////////////////////////////////////////////////
//
// 3 stages to setup :
// 1: McatNloWZ specifies with WZ MC we plot
// 2: reg: specifies which fake region is plotted
// 3: BM specifies if we plot 1.2 or 4.7 fb-1
//
//////////////////////////////////////////////////////
TH1::SetDefaultSumw2(true);
if(argc == 1) {
cout << "No config file set" << endl;
return 0;
}
/// Set Plotting style
setTDRStyle();
gStyle->SetPalette(1);
//read in config
for (int i = 1; i < argc; ++i) {
string configfile = argv[i];
SetUpMasterConfig(configfile);
int a =MakeCutFlow_Plots(configfile);
}
system(("scp -r " + output_path + " jalmond@lxplus.cern.ch:~/www/SNU/WebPlots/").c_str());
cout << "Open plots in " << output_index_path << endl;
return 0;
}
int MakeCutFlow_Plots(string configfile){
std::string pname = "/home/jalmond/WebPlots/"+ path + "/indexCMS.html";
std::string phistname = "/home/jalmond/WebPlots/"+ path + "/histograms/" + histdir + "/indexCMS.html";
output_path = "/home/jalmond/WebPlots/"+ path ;
output_index_path = string("https://jalmond.web.cern.ch/jalmond/SNU/WebPlots/")+ path + "/histograms/" + histdir + "/indexCMS.html";
system(("mkdir /home/jalmond/WebPlots/" + path).c_str());
system(("mkdir /home/jalmond/WebPlots/" + path+ "/histograms/").c_str());
system(("mkdir /home/jalmond/WebPlots/" + path+"/histograms/" + histdir + "/").c_str());
histpage.open(phistname.c_str());
page.open(pname.c_str());
page << "<html><font face=\"Helvetica\"><head><title> HvyN Analysis </title></head>" << endl;
page << "<body>" << endl;
page << "<h1> HvyN Analysis Plots </h1>" << endl;
page << "<br> <font size=\"4\"><b> " << message << " </b></font> <br><br>" << endl;
page << "<a href=\"histograms/" +histdir + "/indexCMS.html\">"+ histdir + "</a><br>";
//MakeCutFlow(histdir);
int M=MakePlots(histdir);
return 1;
}
int MakePlots(string hist) {
////////////////////// ////////////////
//// MAIN PART OF CODE for user/
///////////////////////////////////////
//// What samples to use in histogram
vector<pair<pair<vector<pair<TString,float> >, int >, TString > > samples;
vector<pair<pair<vector<pair<TString,float> >, int >, TString > > samples_ss;
vector<string> cut_label;
//// Sets flags for using CF/NP/logY axis/plot data/ and which mc samples to use
SetUpConfig( samples, samples_ss, cut_label);
cuts.clear();
// ----------Get list of cuts to plot ----------------------
ifstream cut_name_file(cutfile.c_str());
if(!cut_name_file) {
cerr << "Did not find " + cutfile + ", exiting ..." << endl;
return 1;
}
while(!cut_name_file.eof()) {
string cutname;
cut_name_file >> cutname;
if(cutname=="END") break;
//cutname = cutname + "POGTight";
allcuts.push_back(cutname);
}
ifstream histo_name_file(histfile.c_str());
if(!histo_name_file) {
cerr << "Did not find " << histfile << ", exiting ..." << endl;
return 1;
}
histpage << "<table border = 1><tr>"
<< "<th> <a name=\"PlotName (variable_Cut)\"> PlotName (variable_Cut) </a> </th>"
<< "<th> Data/MC Plot </th>"
<< "<th> Data/MC LogPlots </th>"
<< "</tr>" << endl;
while(!histo_name_file.eof()) {
string h_name;
int rebin;
double xmin,xmax;
histo_name_file >> h_name;
if(repeat(h_name))continue;
if(h_name=="END") break;
histo_name_file >> rebin;
histo_name_file >> xmin;
histo_name_file >> xmax;
if(h_name.find("#")!=string::npos) continue;
for(unsigned int ncut=0; ncut<allcuts.size(); ncut++){
string name = allcuts.at(ncut) + "/" + h_name+ "_" + allcuts.at(ncut);
if(TString(allcuts.at(ncut)).Contains("purw")) name = h_name+ "_" + allcuts.at(ncut);
bool isSS(false);
//if(TString(allcuts.at(ncut)).Contains("SS"))isSS = true;
cout << "###################### " << name << " ###########################"<< endl;
/// Make nominal histogram stack
map<TString, TH1*> legmap;
THStack* mstack;
if(!isSS) mstack= MakeStack(samples , "Nominal",name, xmin, xmax, legmap, rebin , true);
else mstack=MakeStack(samples_ss, "Nominal",name, xmin, xmax, legmap, rebin , true);
THStack* mstack_nostat;
if(!isSS)mstack_nostat = MakeStack(samples , "Nominal",name, xmin, xmax, legmap, rebin , false);
else mstack_nostat = MakeStack(samples_ss , "Nominal",name, xmin, xmax, legmap, rebin , false);
//// mhist sets error config
map<TString,TH1*> mhist;
mhist["Nominal"] = MakeSumHist(mstack);
map<TString,TH1*> mhist_nostat;
mhist_nostat["Nominal"] = MakeSumHist(mstack_nostat);
TH1* hup = MakeStackUp(mhist, name+"UP");
TH1* hup_nostat = MakeStackUp(mhist_nostat, name+"UPnostat");
TH1* hdown = MakeStackDown(mhist, name+"DOWN");
cout << "Final Background Integral = " << MakeSumHist(mstack)->Integral() << " : Up = " << hup->Integral() << " : Down= " << hdown->Integral() << endl;
/// Make data histogram
ylog=false;
if(TString(name).Contains("llmass")){ylog=true;}
if(TString(name).Contains("LeptonPt")){ylog=true;}
if(TString(name).Contains("Tri")) {ylog=false;}
//if(TString(name).Contains("SSE")) {ylog=false;}
TH1* hdata = MakeDataHist(name, xmin, xmax, hup, ylog, rebin);
CheckHist(hdata);
float ymin (0.001), ymax( 0.);
ymax = GetMaximum(hdata, hup, ylog, name, xmax);
if(showdata)cout << "Total data = " << hdata->Integral() << endl;
scale = 1.;
/// Make legend
TLegend* legend = MakeLegend(legmap, hdata, showdata, ylog, ymax, xmax);
vector<THStack*> vstack;
vstack.push_back(mstack);
vstack.push_back(mstack_nostat);
TCanvas* c = CompDataMC(hdata,vstack,hup,hdown, hup_nostat, legend,name,rebin,xmin,xmax, ymin,ymax, path, histdir,ylog, showdata, channel);
string canvasname = c->GetName();
canvasname.erase(0,4);
PrintCanvas(c, histdir, canvasname, c->GetName());
}
}
page.close();
return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
///%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
/// CODE FOR CUTFLOW
///%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
/////////////////////////////////////////////////////////////////////////////////////////////////////////
void MakeCutFlow(string type){
vector<string> cut_label;
vector<pair<pair<vector<pair<TString,float> >, int >, TString > > cfsamples;
vector<pair<pair<vector<pair<TString,float> >, int >, TString > > cfsamples_ss;
SetUpConfig( cfsamples, cfsamples_ss, cut_label);
cuts.clear();
// ----------Get list of cuts to plot ----------------------
cout << cutfile << endl;
ifstream cut_name_file(cutfile.c_str());
while(!cut_name_file.eof()) {
string cutname;
cut_name_file >> cutname;
if(cutname=="END") break;
//cutname = cutname+"POGTight";
cut_label.push_back(cutname);
cout << "$$$$$$$$$ " << hist << " $$$$$$$$$$$$$$$$$$$$" << endl;
cout << cutname << endl;
if(TString(cutname).Contains("purw")) return;
else cuts.push_back((cutname+ hist +"_" + cutname).c_str());
}
vector<float> totalnumbers;
vector<float> totalnumbersup;
vector<float> totalnumbersdown;
int i_cut(0);
for(vector<string>::iterator it = cuts.begin(); it!=cuts.end(); it++, i_cut++){
bool isSS=false;
//if(TString(*it).Contains("SS"))isSS = true;
vector<pair<vector<pair<TString,float> >, TString> > samples;
if(!isSS){
for(vector<pair<pair<vector<pair<TString,float> >, int >, TString > >::iterator it2 = cfsamples.begin(); it2!=cfsamples.end(); it2++){
samples.push_back(make_pair(it2->first.first,it2->second));
}
}
else{
for(vector<pair<pair<vector<pair<TString,float> >, int >, TString > >::iterator it2 = cfsamples_ss.begin(); it2!=cfsamples_ss.end(); it2++){
samples.push_back(make_pair(it2->first.first,it2->second));
}
}
/// Vectors for cutflow table
map<TString,float> samples_numbers;
map<TString,float> samples_numbers_staterr;
map<TString,float> samples_numbers_up;
map<TString,float> samples_numbers_down;
/// Vector for systematic table
map<TString,float> syst_stat;
map<TString,float> syst_norm;
map<TString,float> syst_total;
float totalbkg(0.),totalbkgdown(0.), totalbkgup(0.);
for(vector<pair<vector<pair<TString,float> >, TString> >::iterator it2 = samples.begin() ; it2!= samples.end(); it2++){
TString cutname = *it;
totalbkg+= Calculate(*it,"Normal",*it2);
totalbkgup+= Calculate(*it,"Up",*it2);
totalbkgdown+= Calculate(*it,"Down",*it2);
samples_numbers[it2->second] = Calculate(cutname,"Normal",*it2);
samples_numbers_up[it2->second] = Calculate(cutname,"Down",*it2);
samples_numbers_down[it2->second] = Calculate(cutname,"Up",*it2);
samples_numbers_staterr[it2->second] = Calculate(cutname,"StatErr",*it2);
}
float totaldata(0.);
if(showdata) totaldata = GetIntegral(*it,"data","data");
float errdata(0.);
if(showdata) errdata= GetError(*it,"data","data");
float totalerr_up(0.),totalerr_down(0.),totalerrup(0.),totalerrdown(0.),total_staterr(0.);
for(map<TString,float>::iterator mapit = samples_numbers.begin(); mapit!= samples_numbers.end(); mapit++){
map<TString,float>::iterator mapit_up;
mapit_up = samples_numbers_up.find(mapit->first);
map<TString,float>::iterator mapit_down;
mapit_down = samples_numbers_down.find(mapit->first);
map<TString,float>::iterator mapit_stat;
mapit_stat = samples_numbers_staterr.find(mapit->first);
totalerr_up += ( mapit_up->second*mapit_up->second+ mapit_stat->second*mapit_stat->second);
totalerr_down += (mapit_down->second*mapit_down->second + mapit_stat->second*mapit_stat->second);
totalerrup += (mapit_up->second*mapit_up->second);
totalerrdown += (mapit_down->second*mapit_down->second);
total_staterr += mapit_stat->second*mapit_stat->second;
TString sample = mapit->first;
if(sample.Contains("t#bar{t},t/#bar{t},t/#bar{t}W,t#bar{t}V")) sample = "t$\\bar{t}$,t/$\\bar{t}$,t/$\\bar{t}$W,t$\\bar{t}$V";
else if(sample.Contains("t#bar{t}")) sample = "t$\bar{t}$";
else if(sample.Contains("t#bar{t}V")) sample = "t$\bar{t}$+V";
else if(sample.Contains("t/#bar{t}")) sample = "t/$\bar{t}$";
if(sample.Contains("DY#rightarrow ll; 10 < m(ll) < 50")) sample = "DY$\\rightarrow$ ll; 10 < m(ll) < 50";
if(sample.Contains("DY#rightarrow ll; m(ll) > 50")) sample = "DY$\\rightarrow$ ll; m(ll) > 50";
if(sample.Contains("DY#rightarrow ll")) sample = "DY$\\rightarrow$ ll";
cout << sample << " background = " << mapit->second<< " +- " << mapit_stat->second << " + " << mapit_up->second << " - " << mapit_down->second << endl;
}
totalerr_up = sqrt(totalerr_up);
totalerr_down = sqrt(totalerr_down);
total_staterr = sqrt(total_staterr);
totalerrup = sqrt(totalerrup);
totalerrdown = sqrt(totalerrdown);
cout << "Total Bkg = " << totalbkg << "+- " << total_staterr << " + " << totalerrup << " - " << totalerrdown << endl;
if(showdata)cout << "Total Data = " << totaldata << endl;
cout << "-------------" << endl;
if(totaldata > totalbkg)cout <<"Significance = " << (totaldata - totalbkg) / (sqrt( (errdata*errdata) + (totalerr_up*totalerr_up))) << endl;
else cout <<"Significance = " << (totaldata - totalbkg) / (sqrt( (errdata*errdata) + (totalerr_down*totalerr_down))) << endl;
float significance = (totaldata - totalbkg) / (sqrt( (errdata*errdata) + (totalerr_up*totalerr_up))) ;
if(significance < 0.) significance = (totaldata - totalbkg) / (sqrt( (errdata*errdata) + (totalerr_down*totalerr_down))) ;
//// Make TEX file
ofstream ofile_tex;
string latex_file = "Tables/" + cut_label.at(i_cut) + ".tex";
ofile_tex.open(latex_file.c_str());
ofile_tex.setf(ios::fixed,ios::floatfield);
ofile_tex << "\\documentclass[10pt]{article}" << endl;
ofile_tex << "\\usepackage{epsfig,subfigure,setspace,xtab,xcolor,array,colortbl}" << endl;
ofile_tex << "\\begin{document}" << endl;
ofile_tex << "\\input{Tables/" + cut_label.at(i_cut) + "Table.txt}" << endl;
ofile_tex << "\\end{document}" << endl;
/// Make text file
ofstream ofile;
string latex = "Tables/" + cut_label.at(i_cut) + "Table.txt";
ofile.open(latex.c_str());
ofile.setf(ios::fixed,ios::floatfield);
ofile.precision(1);
ofile << "\\begin{table}[h]" << endl;
ofile << "\\begin{center}" << endl;
ofile << "\\begin{tabular}{lr@{\\hspace{0.5mm}}c@{\\hspace{0.5mm}}c@{\\hspace{0.5mm}}l}" << endl;
ofile << "\\hline" << endl;
ofile << "\\hline" << endl;
//ofile << "Source & \\multicolumn{4}{c}{$\\mu\\mu\\mu$} \\"<<"\\" << endl;
ofile << "Source & \\multicolumn{4}{c}{" << columnname << "} \\"<<"\\" << endl;
ofile << "\\hline" << endl;
for(map<TString,float>::iterator mapit = samples_numbers.begin(); mapit!= samples_numbers.end(); mapit++){
map<TString,float>::iterator mapit_up;
mapit_up = samples_numbers_up.find(mapit->first);
map<TString,float>::iterator mapit_down;
mapit_down = samples_numbers_down.find(mapit->first);
map<TString,float>::iterator mapit_stat;
mapit_stat = samples_numbers_staterr.find(mapit->first);
TString sample = mapit->first;
if(sample.Contains("t#bar{t},t/#bar{t},t/#bar{t}W,t#bar{t}V")) sample = "t$\\bar{t}$,t/$\\bar{t}$,t/$\\bar{t}$W,t$\\bar{t}$V";
else if(sample.Contains("t/#bar{t}")) sample = "t/$\\bar{t}$";
else if(sample.Contains("t#bar{t}V")) sample = "t$\\bar{t}$+V";
else if(sample.Contains("t#bar{t}")) sample = "t$\\bar{t}$";
if(sample.Contains("DY#rightarrow ll; 10 < m(ll) < 50")) sample = "DY$\\rightarrow$ ll; 10 < m(ll) < 50";
if(sample.Contains("DY#rightarrow ll; m(ll) > 50")) sample = "DY$\\rightarrow$ ll; m(ll) > 50";
if(sample.Contains("DY#rightarrow ll")) sample = "DY$\\rightarrow$ ll";
if(mapit->second!=0.0){
ofile << sample + "&" << mapit->second << "& $\\pm$& " << mapit_stat->second << "&$^{+" << mapit_up->second << "}_{-" << mapit_down->second << "}$" ;
ofile << "\\" << "\\" << endl;
}
}
ofile << "\\hline" << endl;
ofile << "Total&" << totalbkg << "& $\\pm$&" << total_staterr << "&$^{+" << totalerrup << "}_{-" << totalerrdown << "}$" ;
ofile << "\\" << "\\" << endl;
ofile << "\\hline" << endl;
ofile << "Data& \\multicolumn{4}{c}{$" << totaldata << "$}\\" << "\\" <<endl;
ofile << "\\hline" << endl;
if(significance < 0) ofile << "Signficance& \\multicolumn{4}{c}{$" << significance << "\\sigma$}\\" << "\\" <<endl;
if(significance > 0) ofile << "Signficance& \\multicolumn{4}{c}{$+" << significance << "\\sigma$}\\" << "\\" <<endl;
ofile << "\\hline" << endl;
ofile << "\\hline" << endl;
ofile << "\\end{tabular}" << endl;
ofile << "\\caption{" << caption << "}" << endl;
ofile << "\\end{center}" << endl;
ofile << "\\end{table}" << endl;
string latex_command = "latex Tables/" + cut_label.at(i_cut) +".tex";
string dvi_command = "dvipdf " + cut_label.at(i_cut) +".dvi";
string mv_command = "mv " + cut_label.at(i_cut) +".pdf /home/jalmond/WebPlots/" + path +"/histograms/"+ histdir ;
system((latex_command.c_str()));
system((dvi_command.c_str()));
system((mv_command.c_str()));
system(("rm *aux"));
system(("rm *log"));
system(("rm *dvi"));
string cftitle = cut_label.at(i_cut);
histpage << "<tr><td>"<< "cutflow " + cut_label.at(i_cut) <<"</td>"<<endl;
histpage <<"<td>"<<endl;
histpage << "<a href=\"" << cut_label.at(i_cut) << ".pdf\">";
histpage << "Cutflow: " + cut_label.at(i_cut) + ".pdf</p>";
histpage << "</td>" << endl;
}
return;
}
bool repeat (string hname){
map<string,int>::iterator mit = norepeatplot.find(hname);
if(mit!=norepeatplot.end())return true;
else{
norepeatplot[hname]=1;
return false;
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
void PrintCanvas(TCanvas* c1, string folder, string plot_description, string title){
std::string tpdf = "/home/jalmond/WebPlots/"+ path + "/histograms/"+folder+"/"+title;
if(plot_description.empty())plot_description=title;
histpage << "<tr><td>"<< plot_description <<"</td>"<<endl;
histpage <<"<td>"<<endl;
histpage << "<a href=\"" << title.c_str() << ".png\">";
histpage << "<img src=\"" << title.c_str() << ".png\" width=\"100%\"/>";
histpage << "</td>" << endl;
histpage <<"<td>"<<endl;
histpage << "<a href=\"" << title.c_str() << "_log.png\">";
histpage << "<img src=\"" << title.c_str() << "_log.png\" width=\"100%\"/>";
histpage << "</td>" << endl;
return;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
TLegend* MakeLegend(map<TString, TH1*> map_legend,TH1* hlegdata, bool rundata , bool logy, float ymax, float xmax){
double x1 = 0.5;
double y1 = 0.5;
double x2 = 0.6;
double y2 = 0.9;
int nbinsX=hlegdata->GetNbinsX();
int max_bin = 0;
int ymax_bin = 0;
float r_max_tmp = 0.;
for(unsigned int ibin=1; ibin < hlegdata->GetNbinsX()+1; ibin++){
float r_max = hlegdata->GetBinContent(ibin) / hlegdata->GetMaximum();
if(r_max > r_max_tmp){
r_max_tmp= r_max;
ymax_bin= ibin;
}
if( xmax >= hlegdata->GetBinLowEdge(ibin) && xmax < hlegdata->GetBinLowEdge(ibin+1)) max_bin = ibin;
}
if(max_bin == 0) max_bin = hlegdata->GetNbinsX()+1;
if(ymax_bin/max_bin > 0.5){
x1 = 0.2;
y1 = 0.6;
x2 = 0.5;
y2 = 0.9;
}
else{
x1 = 0.6;
y1 = 0.7;
x2 = 0.95;
y2 = 0.9;
}
cout << "Test" << endl;
TLegend* legendH = new TLegend(x1,y1,x2,y2);
legendH->SetFillColor(kWhite);
legendH->SetTextFont(42);
legendH->SetBorderSize(0);
legendH->SetTextSize(0.025);
legendH->SetNColumns(2);
if(rundata) legendH->AddEntry(hlegdata,"Data","pE");
// for(map<TString, TH1*>::iterator it = map_legend.begin(); it!= map_legend.end(); it++){
vector<TString> legorder;
legorder.push_back("DY#rightarrow ll; 10 < m(ll) < 50");
legorder.push_back("Wjets");
legorder.push_back("DY#rightarrow ll; m(ll) > 50");
legorder.push_back("t#bar{t},t/#bar{t},t/#bar{t}W,t#bar{t}V");
legorder.push_back("Diboson");
//legorder.push_back("QCD");
// legorder.push_back("Other");
//legorder.push_back("Mismeas. Charge Background");
//legorder.push_back("Misid. Lepton Background");
map<double, TString> order_hists;
for(map<TString, TH1*>::iterator it = map_legend.begin(); it!= map_legend.end(); it++){
order_hists[it->second->Integral()] = it->first;
}
if(map_legend.size() < 3){
for(map<TString, TH1*>::iterator it = map_legend.begin(); it!= map_legend.end(); it++) {
legendH->AddEntry(it->second, it->first,"f");
}
}else{
//for(unsigned int ileg = 0; ileg < legorder.size() ; ileg++){
//map<TString, TH1*>::iterator it = map_legend.find(legorder.at(ileg));
//if(it->second)legendH->AddEntry(it->second,it->first.Data(),"f");
// }
for(map<double, TString>::iterator it =order_hists.begin(); it!= order_hists.end(); it++) {
map<TString, TH1*>::iterator it2 = map_legend.find(it->second);
if(it->first > 0)legendH->AddEntry(it2->second,it->second.Data(),"f");
}
}
legendH->SetFillColor(kWhite);
legendH->SetTextFont(42);
return legendH;
}
TH1* MakeDataHist(string name, double xmin, double xmax, TH1* hup, bool ylog, int rebin){
/// Make data histogram
TFile* file_data = TFile::Open((dataloc).c_str());
TH1* hdata = dynamic_cast<TH1*> ((file_data->Get(name.c_str()))->Clone());
hdata->Rebin(rebin);
float ymin (0.01), ymax( 1000000.);
ymax = GetMaximum(hdata, hup, ylog, name, xmax);
/// Set Ranges / overflows
FixOverUnderFlows(hdata, xmax);
hdata->GetXaxis()->SetRangeUser(xmin,xmax);
hdata->GetYaxis()->SetRangeUser(ymin, ymax);
hdata->SetMarkerStyle(20);
hdata->SetMarkerSize(1.6);
//// X title
SetTitles(hdata, name);
return hdata;
}
void CheckHist(TH1* h){
if(!h) {
cout << "Not able to find data histogram" << endl;
}
}
vector<pair<TString,float> > InitSample (TString sample){
vector<pair<TString,float> > list;
if(sample.Contains("dylow_")){
list.push_back(make_pair("DYJets_10to50",0.2));
}
if(sample.Contains("dyhigh_")){
list.push_back(make_pair("DYJets",0.2));
}
if(sample.Contains("dy_")){
//list.push_back(make_pair("DY10to50_MCatNLO",0.2));
//list.push_back(make_pair("DY50plus_MCatNLO",0.2));
list.push_back(make_pair("DYJets_10to50",0.2));
list.push_back(make_pair("DYJets",0.2));
}
if(sample.Contains("wjet_")){
list.push_back(make_pair("WJets",0.2));
}
///// Top samples //////////////////
if(sample.Contains("top")){
list.push_back(make_pair("SingleTop_tW",0.25));
list.push_back(make_pair("SingleTbar_tW",0.25));
list.push_back(make_pair("SingleTop_s",0.25));
list.push_back(make_pair("SingleTop_t",0.25));
list.push_back(make_pair("TT_powheg",0.25));
list.push_back(make_pair("ttW",0.25));
list.push_back(make_pair("ttZ",0.25));
}
if(sample.Contains("qcd"))
{
list.push_back(make_pair("QCD_Pt-20to30_EMEnriched",0.30));
list.push_back(make_pair("QCD_Pt-300toInf_EMEnriched",0.30));
list.push_back(make_pair("QCD_Pt-30to50_EMEnriched",0.30));
list.push_back(make_pair("QCD_Pt-170to300_EMEnriched",0.30));
list.push_back(make_pair("QCD_Pt-50to80_EMEnriched",0.30));
list.push_back(make_pair("QCD_Pt-120to170_EMEnriched",0.30));
list.push_back(make_pair("QCD_Pt-80to120_EMEnriched",0.30));
}
//////// Diboson ////////
if(sample.Contains("vv")){
list.push_back(make_pair("WZTo3LNu_powheg",0.15));
//list.push_back(make_pair("WWTo2L2Nu",0.15));
//list.push_back(make_pair("WWToLNuQQ",0.15));
list.push_back(make_pair("ZZTo4L_powheg",0.15));
}
if(sample.Contains("other_")){
list.push_back(make_pair("WpWpQCD",0.15));
list.push_back(make_pair("WpWpEWK",0.15));
list.push_back(make_pair("WWW",0.15));
list.push_back(make_pair("WGtoLNuG",0.15));
list.push_back(make_pair("ZGto2LG",0.15));
list.push_back(make_pair("ZZZ",0.15));
list.push_back(make_pair("ttH_nonbb",0.15));
list.push_back(make_pair("ttH_bb",0.15));
}
if(sample.Contains("prompt")){
list.push_back(make_pair("WWW",0.25));
list.push_back(make_pair("TTWW",0.25));
list.push_back(make_pair("TTG",0.25));
list.push_back(make_pair("ZZZ",0.25));
list.push_back(make_pair("WWG",0.25));
list.push_back(make_pair("HtoWW",0.25));
list.push_back(make_pair("HtoTauTau",0.22));
list.push_back(make_pair("ggHtoZZ",0.22));
list.push_back(make_pair("WZ_py",0.12));
list.push_back(make_pair("ZZ_py",0.09));
list.push_back(make_pair("WW_dp",0.5));
list.push_back(make_pair("ttW",0.25));
list.push_back(make_pair("ttZ",0.25));
}
if(sample.Contains("nonprompt_DoubleEG")){
list.push_back(make_pair("nonprompt_DoubleEG",0.34));
}
if(sample.Contains("chargeflip")){
list.push_back(make_pair("chargeflip",0.12));
}
if(list.size()==0) cout << "Error in making lists " << sample<< endl;
return list;
}
void CheckSamples(int nsamples){
if(nsamples==0) {
cout << "No sample in this vector" << endl;
exit(1);
}
return;
}
THStack* MakeStack(vector<pair<pair<vector<pair<TString,float> >, int >, TString > > sample, TString type, string name, float xmin, float xmax,map<TString, TH1*>& legmap , int rebin, bool include_syst_err){
string clonename = name;
if(include_syst_err) clonename += "_andsysyerr";
THStack* stack = new THStack(clonename.c_str(), clonename.c_str());
bool debug(false);
if(type.Contains("Nominal")) debug=true;
TString fileloc = "";
TDirectory* origDir = gDirectory;
float sum_integral=0.;
for(vector<pair<pair<vector<pair<TString,float> >, int >, TString > >::iterator it = sample.begin() ; it!= sample.end(); it++){
if(type.Contains("Nominal")) fileloc = mcloc;
if(!type.Contains("Nominal")) {
if(it->first.first.at(0).first.Contains("nonprompt_DoubleEG"))fileloc=mcloc;
}
CheckSamples( it->first.first.size() );
int isample=0;
TFile* file = TFile::Open((fileloc+ fileprefix + it->first.first.at(isample).first + filepostfix).Data());
cout << fileloc+ fileprefix + it->first.first.at(isample).first + filepostfix << endl;
if(!file) cout << "Could not open " << fileloc+ fileprefix + it->first.first.at(isample).first + filepostfix << endl;
cout << "file = " << file << endl;
gROOT->cd();
TDirectory* tempDir = 0;
int counter = 0;
while (not tempDir) {
std::stringstream dirname;
dirname << "WRHNCommonLeptonFakes_%i" << counter;
if (gROOT->GetDirectory((dirname.str()).c_str())) {
++counter;
continue;
}
tempDir = gROOT->mkdir((dirname.str()).c_str());
}
tempDir->cd();
cout << clonename.c_str() << endl;
TH1* h_tmp = dynamic_cast<TH1*> ((file->Get(name.c_str()))->Clone(clonename.c_str()));
cout << h_tmp << endl;
while(!h_tmp) {
isample++;
gROOT->cd();
file = TFile::Open((fileloc+ fileprefix + it->first.first.at(isample).first + filepostfix).Data());
tempDir->cd();
h_tmp = dynamic_cast<TH1*> ((file->Get(name.c_str()))->Clone(clonename.c_str()));
}
CheckHist(h_tmp);
if(debug)cout << it->second << " contribution " << 1 << "/" << it->first.first.size() << " is from " << fileprefix + it->first.first.at(isample).first + filepostfix <<" : Integral = " <<h_tmp->Integral() << " " << fileloc << endl;
for(unsigned int i=isample+1; i < it->first.first.size(); i++){
clonename+="A";
origDir->cd();
TFile* file_loop = TFile::Open((fileloc+ fileprefix + it->first.first.at(i).first + filepostfix).Data());
tempDir->cd();
TH1* h_loop = dynamic_cast<TH1*> ((file_loop->Get(name.c_str()))->Clone(clonename.c_str()));
if(!h_loop) continue;
CheckHist(h_loop);
h_tmp->Add(h_loop);
if(debug)cout << it->second << " contribution " <<i+1 <<"/" << it->first.first.size() << " is from ExampleAnalyzer_SK" << it->first.first.at(i).first << ".NTUP_SMWZ.Reco.root : Integral = " <<h_loop->Integral() << " sum integral = " << h_tmp->Integral() << endl;
file_loop->Close();
}
/// TH1* is now made. Now make pretty
FixOverUnderFlows(h_tmp, xmax);
///Set colors
h_tmp->SetFillColor(it->first.second);
//h_tmp->SetLineColor(it->first.second);
h_tmp->SetLineColor(kBlack);
if(!stack->GetHists()) {
stack->SetName( (string("s_") + name).c_str() );
stack->SetTitle( (string("s_") + name).c_str() );
SetTitles(h_tmp, name);
}//stack empt
h_tmp->Rebin(rebin);
h_tmp->SetLineWidth(3.0);
SetErrors(h_tmp, it->first.first.at(0).second, include_syst_err );
stack->Add(h_tmp);
sum_integral+=h_tmp->Integral();
if(type.Contains("Nominal")) {
legmap[it->second] = h_tmp;
}
file->Close();
origDir->cd();
}
return stack;
}
TH1* MakeStackUp(map<TString, TH1*> map_of_stacks, TString clonename){
map<TString, TH1*>::iterator it = map_of_stacks.find("Nominal");
float norm=1;
TH1* h_up = dynamic_cast<TH1*>(it->second->Clone(clonename.Data())); // copy of nominal
for(int binx=1 ; binx < h_up->GetNbinsX()+1; binx++){
float nom_content = h_up->GetBinContent(binx);
float nom_error = h_up->GetBinError(binx);
/// Now use 5%+ norm + stat error
float errup2 = nom_error*nom_error + 0.05*0.05*nom_content*nom_content;
if(clonename.Contains("stat")) errup2 = nom_error*nom_error;
/// add rest of systs
float new_bin = nom_content + sqrt(errup2);
h_up->SetBinContent(binx,new_bin);
}
return h_up;
}
TH1* MakeStackDown(map<TString, TH1*> map_of_stacks, TString clonename){
map<TString, TH1*>::iterator it = map_of_stacks.find("Nominal");
float norm=1;
TH1* h_down = dynamic_cast<TH1*>(it->second->Clone(clonename.Data())); // copy of nominal
for(int binx=1 ; binx < h_down->GetNbinsX()+1; binx++){
float nom_content = h_down->GetBinContent(binx);
float nom_error = h_down->GetBinError(binx);
//// nom_error = stat err + normalisation error, set previously on nom hist
float errdown2 = nom_error*nom_error;
/// Now use 5%+ norm + stat error
float errup2 = nom_error*nom_error + 0.05*0.05*nom_content*nom_content;
float new_bin = nom_content - sqrt(errdown2);
h_down->SetBinContent(binx,new_bin);
}
return h_down;
}
TH1* MakeSumHist(THStack* thestack){
TH1* hsum=0;
TList* list = thestack->GetHists();
TIter it(list, true);
TObject* obj=0;
while( (obj = it.Next()) ) {
TH1* h = dynamic_cast<TH1*>(obj);
if(!hsum) hsum = (TH1*)h->Clone( (string(h->GetName()) + "_sum").c_str() );
else {
hsum->Add(h, 1.0);
}
}//hist loop
return hsum;
}
void SetErrors(TH1* hist, float normerr, bool includestaterr ){
for(int binx =1; binx < hist->GetNbinsX()+1; binx++){
float newbinerr = hist->GetBinError(binx)*hist->GetBinError(binx) + hist->GetBinContent(binx)*hist->GetBinContent(binx)*normerr*normerr;
if(!includestaterr) newbinerr =hist->GetBinError(binx)*hist->GetBinError(binx) ;
hist->SetBinError(binx, sqrt(newbinerr));
}
return;
}
void SetTitles(TH1* hist, string name){
string xtitle ="";
string ytitle ="Entries";
float binedge_up = hist->GetBinLowEdge(2);
float binedge_down = hist->GetBinLowEdge(1);
float width = binedge_up - binedge_down;
std::ostringstream str_width;
str_width<< int(width);
cout << "Hist " << name << " Add GeV to y title = " << HistInGev(name) << endl;
if(HistInGev(name)) ytitle = "Entries / " +str_width.str() + " GeV";
if(name.find("h_MET")!=string::npos){
xtitle="E^{miss}_{T} (GeV)";
if(name.find("phi")!=string::npos){
xtitle="#phi_{E^{miss}_{T}} ";
}
}
if(name.find("h_MT")!=string::npos) xtitle="M_{T} (GeV)";
if(name.find("h_dphi_METe")!=string::npos) xtitle="#Delta (#phi_{E^{miss}_{T}} - #phi_{el})";
if(name.find("h_dphi_METm")!=string::npos) xtitle="#Delta (#phi_{E^{miss}_{T}} - #phi_{mu})";
if(name.find("h_NoHFMET")!=string::npos) xtitle="NoHF E^{miss}_{T} (GeV)";
if(name.find("h_PFMET")!=string::npos) xtitle="E^{miss}_{T} (GeV)";
if(name.find("h_jet_emfra")!=string::npos) xtitle="Jet EMFrac";
if(name.find("jet_el_ptratio")!=string::npos) xtitle="El p_{T}/ Jet p_{T}";
if(name.find("muons_eta")!=string::npos)xtitle="Muon #eta";
if(name.find("muons_phi")!=string::npos)xtitle="Muon #phi";
if(name.find("MuonPt")!=string::npos)xtitle="Muon p_{T} (GeV)";
if(name.find("MuonD0")!=string::npos)xtitle="d0";
if(name.find("MuonD0Sig")!=string::npos)xtitle="d0/#Sigma_{d0}";
if(name.find("LeptonPt")!=string::npos)xtitle="Lepton p_{T} (GeV/c)";
if(name.find("leadingLeptonPt")!=string::npos)xtitle="Leading lepton p_{T} (GeV/c)";
if(name.find("secondLeptonPt")!=string::npos)xtitle="Second lepton p_{T} (GeV/c)";
if(name.find("leadingMuonPt")!=string::npos)xtitle="Lead p_{T} (GeV)";
if(name.find("secondMuonPt")!=string::npos)xtitle="Second p_{T} (GeV)";
if(name.find("thirdMuonPt")!=string::npos)xtitle="Third p_{T} (GeV)";
if(name.find("jets_pt")!=string::npos)xtitle="Jet p_{T} (GeV)";
if(name.find("LeptonEta")!=string::npos)xtitle="Lepton #eta";
if(name.find("electrons_eta")!=string::npos)xtitle="Electron #eta";
if(name.find("electrons_phi")!=string::npos)xtitle="Electron #phi";
if(name.find("el_pt")!=string::npos)xtitle="Electron p_{T} (GeV)";
if(name.find("leadingElectronPt")!=string::npos)xtitle="Leading electron p_{T} (GeV/c)";
if(name.find("secondElectronPt")!=string::npos)xtitle="Trailing electron p_{T} (GeV/c)";
if(name.find("thirdELectronPt")!=string::npos)xtitle="Third electron p_{T} (GeV)";
if(name.find("lljjmass")!=string::npos)xtitle="e^{#pm}#mu^{#pm}jj invariant mass (GeV/c^{2})";
if(name.find("llmass")!=string::npos)xtitle="ll invariant mass (GeV/c^{2})";
if(name.find("l1jjmass")!=string::npos)xtitle="l_{1}jj invariant mass (GeV/c^{2})";
if(name.find("l2jjmass")!=string::npos)xtitle="l_{2}jj invariant mass (GeV/c^{2})";
if(name.find("charge")!=string::npos)xtitle="sum of lepton charge";
if(name.find("mumumass")!=string::npos)xtitle="m(#mu#mu) (GeV)";
if(name.find("eemass")!=string::npos)xtitle="e^{#pm}e^{#pm} invariant mass (GeV)";
if(name.find("emumass")!=string::npos)xtitle="e^{#pm}#mu^{#pm} invariant mass (GeV)";
if(name.find("jets_eta")!=string::npos)xtitle="jet #eta";
if(name.find("jets_phi")!=string::npos)xtitle="jet #phi";
if(name.find("Njets")!=string::npos)xtitle="Number of jets";
if(name.find("Nbjet")!=string::npos)xtitle="Number of bjets";
if(name.find("bTag")!=string::npos)xtitle="CSV";
if(name.find("el1jet_mindr")!=string::npos)xtitle="min#Delta R(e_{1}j)";
if(name.find("el2jet_mindr")!=string::npos)xtitle="min#Delta R(e_{2}j)";
if(name.find("leadMuonJetdR")!=string::npos)xtitle="min#Delta R(#mu j)";
if(name.find("leadJetdR")!=string::npos)xtitle="min#Delta R(jj)";
if(name.find("mu1jjmass")!=string::npos)xtitle="m(#mu_{1}jj) (GeV)";
if(name.find("mu2jjmass")!=string::npos)xtitle="m(#mu_{2}jj) (GeV)";
if(name.find("mumujjmass")!=string::npos)xtitle="m(#mu#mujj) (GeV)";
if(name.find("leadElectronJetdR")!=string::npos)xtitle="min#Delta R(e_j)";
if(name.find("e1jjmass")!=string::npos)xtitle="e_{1}jj invariant mass (GeV/c^{2})";
if(name.find("e2jjmass")!=string::npos)xtitle="e_{2}jj invariant mass (GeV/c^{2})";
if(name.find("eejjmass")!=string::npos)xtitle="e^{#pm}e^{#pm}jj invariant mass (GeV/c^{2})";
if(name.find("leadingMuonIso")!=string::npos)xtitle="PF Iso #mu_{1} (GeV)";
if(name.find("secondMuonIso")!=string::npos)xtitle="PF Iso #mu_{2} (GeV)";
if(name.find("leadingElectronIso")!=string::npos)xtitle="PF Iso e_{1} (GeV)";
if(name.find("secondELectronIso")!=string::npos)xtitle="PF Iso e_{2} (GeV)";
if(name.find("MuonD0_")!=string::npos)xtitle="d0";
if(name.find("MuonD0Sig")!=string::npos)xtitle="d0sig";
if(name.find("D0_")!=string::npos)xtitle="d0";
if(name.find("D0Sig")!=string::npos)xtitle="d0sig";
if(name.find("nVertice")!=string::npos)xtitle="Number of vertices";
if(name.find("MuonJetdR")!=string::npos)xtitle="mindR(#mu,jet)";
if(name.find("ElectronJetdR")!=string::npos)xtitle="mindR(e,jet)";
if(name.find("LeadJetdR")!=string::npos)xtitle="mindR(jet,jet)";
if(name.find("LeadMuondR")!=string::npos)xtitle="mindR(#mu,#mu)";
if(name.find("LeadElectrondR")!=string::npos)xtitle="mindR(e,e)";
if(name.find("muon_deta_")!=string::npos)xtitle="#Delta #eta (#mu,#mu)";
if(name.find("el_deta_")!=string::npos)xtitle="#Delta #eta (e,e)";
if(name.find("leaddimudeltaR_")!=string::npos)xtitle="#Delta R (#mu,#mu)";
if(name.find("leaddieldeltaR_")!=string::npos)xtitle="#Delta R (e,e)";
if(name.find("dijetsmass")!=string::npos)xtitle="m(j_{1}j_{2}) (GeV/c^{2})";
if(name.find("leaddijetdr")!=string::npos)xtitle="#Delta R(j_{1}j_{2})";
if(name.find("leadingJetPt")!=string::npos)xtitle="jet1 p_{T} (GeV)";
if(name.find("secondJetPt")!=string::npos)xtitle="jet2 p_{T} (GeV)";
hist->GetXaxis()->SetTitle(xtitle.c_str());
hist->GetYaxis()->SetTitle(ytitle.c_str());
hist->GetXaxis()->SetTitleSize(0.05);
hist->GetYaxis()->SetTitleSize(0.05);
return;
}
bool HistInGev(string name){
bool ingev=false;
cout << name << " : ingev =" << ingev << endl;
if(name.find("ElectronPt")!=string::npos){ ingev=true;cout << "Found ElectronPt" << endl;}
if(name.find("_pt_")!=string::npos){ ingev=true;cout << "Found _pt_" << endl;}
if(name.find("pt")!=string::npos){
if(name.find("LeptonPt")!=string::npos) {ingev=true;cout << "Found pt" << endl;}
else if(name.find("!Lepton")!=string::npos){ ingev=true;cout << "Found pt" << endl;}
}
if(name.find("mass_")!=string::npos){ ingev=true;cout << "Found mass" << endl;}
if(name.find("MET")!=string::npos){ ingev=true;cout << "Found MET" << endl;}
cout << name << " : ingev =" << ingev<< endl;
return ingev;
}
float GetMaximum(TH1* h_data, TH1* h_up, bool ylog, string name, float xmax){
float yscale= 1.2;
int max_bin = 0;
int ymax_bin = 0;
float r_max_tmp = 0.;
for(unsigned int ibin=1; ibin < h_data->GetNbinsX()+1; ibin++){
float r_max = h_data->GetBinContent(ibin) / h_data->GetMaximum();
if(r_max > r_max_tmp){
r_max_tmp= r_max;
ymax_bin= ibin;
}
if( xmax >= h_data->GetBinLowEdge(ibin) && xmax < h_data->GetBinLowEdge(ibin+1)) max_bin = ibin;
}
if(max_bin == 0) max_bin = h_data->GetNbinsX()+1;
bool scale_up=false;
if(ymax_bin/max_bin > 0.5){
}
else{
/*x1 = 0.6;
y1 = 0.7;
x2 = 0.95;
y2 = 0.9;*/
int bin_leg_min = int(0.5*max_bin);
for(unsigned int bin=bin_leg_min; bin < h_data->GetNbinsX()+1; bin++){
if(h_data->GetBinContent(bin) / h_data->GetMaximum() > 0.01 ) scale_up = true;
}
}
if(name.find("llmass")!=string::npos) yscale*=1.3;
if(ylog){
float scale_for_log=1.;
if(h_data->GetMaximum() > 100000) scale_for_log = 10;
else if(h_data->GetMaximum() > 10000) scale_for_log = 10;
else if(h_data->GetMaximum() > 1000) scale_for_log = 10;
yscale*=scale_for_log;
if(scale_up) yscale*= 10000;
}
else{
yscale=1.2;
}
if(name.find("Tri")!=string::npos) {
yscale*=1.5;
if(ylog) yscale*=100.;
}
// if(name.find("Eta")!=string::npos) yscale/=2.;
float max_data = h_data->GetMaximum()*yscale;
float max_bkg = h_up->GetMaximum()*yscale;
if(max_data > max_bkg) return max_data;
else return max_bkg;
if(name.find("eemass")!=string::npos) yscale*=1.3;
if(name.find("eta")!=string::npos) yscale*=2.5;
if(name.find("MET")!=string::npos) yscale*=1.2;
if(name.find("e1jj")!=string::npos) yscale*=1.2;
if(name.find("Nje")!=string::npos) yscale*=1.2;
if(name.find("l2jj")!=string::npos) yscale*=1.3;
if(name.find("charge")!=string::npos) yscale*=1.5;
if(name.find("deltaR")!=string::npos) yscale*=1.5;
if(name.find("bTag")!=string::npos) yscale*=2.5;
if(name.find("emujj")!=string::npos) yscale*=1.3;
if(name.find("dijetmass")!=string::npos) yscale*=1.5;
if(name.find("LeptonPt")!=string::npos) yscale*=0.7;
if(name.find("secondElectronPt")!=string::npos) yscale*=1.2;
return -1000.;
}
float GetTotal(TString cut, vector<pair<TString,float> > samples){
float total(0.);
for(vector<pair<TString,float> >::iterator it = samples.begin(); it!=samples.end(); it++){
total += GetIntegral(cut,(*it).first,"MC");
}
return total;
}
float GetStatError2(TString cut, vector<pair<TString,float> > samples){
float err = GetStatError(cut,samples);
err = err*err;
return err;
}
float GetStatError(TString cut, vector<pair<TString,float> > samples){
TString path = mcloc;
int isample=0;
TFile* f0 = TFile::Open((path+ fileprefix + samples.at(isample).first + filepostfix).Data());
TH1* h_tmp=NULL;
if((f0->Get(cut.Data()))){
h_tmp = dynamic_cast<TH1*> ((f0->Get(cut.Data()))->Clone());
}
float stat_error(-99999.);
while(!h_tmp){
isample++;
f0 = TFile::Open((path+ fileprefix + samples.at(isample).first + filepostfix).Data());
if((f0->Get(cut.Data()))) h_tmp = dynamic_cast<TH1*> ((f0->Get(cut.Data()))->Clone());
}
for(unsigned int i=isample+1; i < samples.size(); i++){
TFile* f = TFile::Open((path+ fileprefix + samples.at(i).first + filepostfix).Data());
if(!f->Get(cut.Data())) continue;
TH1* h = dynamic_cast<TH1*> ((f->Get(cut.Data()))->Clone());
h_tmp->Add(h);
f->Close();
if(i == (samples.size()- 1)){
stat_error = Error(h_tmp);
}
}
if(samples.size()==1) stat_error = Error(h_tmp);
f0->Close();
return stat_error;
}
float GetIntegral(TString cut, TString isample, TString type){
TString filepath = mcloc + fileprefix + isample + filepostfix;
if(type.Contains("data")) filepath=dataloc;
TFile* f = TFile::Open(( filepath.Data()));
if(!((f->Get(cut.Data())))){
cout << "Histogram " << cut << " in " << mcloc+ fileprefix + isample + filepostfix << " not found" << endl;
return 0.;
}
TH1* h = dynamic_cast<TH1*> ((f->Get(cut.Data())->Clone()));
if(!h) {
cout << "Histogram " << cut << " in " << (mcloc + fileprefix + isample + filepostfix) << " not found" << endl;
return 0.;
}
float integral = h->Integral();
f->Close();
return integral;
}
float GetError(TString cut, TString isample, TString type){
TString filepath = mcloc + fileprefix + isample + filepostfix;
if(type.Contains("data")) filepath=dataloc;
TFile* f = TFile::Open(( filepath.Data()));
TH1* h = dynamic_cast<TH1*> ((f->Get(cut.Data())->Clone()));
if(!h) {
cout << "Histogram " << cut << " in " << (path+ fileprefix + isample + filepostfix) << " not found" << endl;
return 0.;
}
float err = Error(h);
f->Close();
return err;
}
float GetNormErr(TString cut, vector<pair<TString,float> > samples){
float norm_err(0.);
int i=0;
for( vector<pair<TString,float> >::iterator it = samples.begin(); it!=samples.end(); it++, i++){
norm_err += GetIntegral(cut,it->first,"MC")* it->second*GetIntegral(cut,it->first,"MC")* it->second;
}
return sqrt(norm_err);
}
float GetNormErr2(TString cut, vector<pair<TString,float> > samples){
float err = GetNormErr(cut,samples);
err = err*err;
return err;
}
float GetErr2(TString cut, vector<pair<TString,float> > samples, TString err_type,TString var){
float err = GetErr(cut,samples,err_type,var);
err = err*err;
return err;
}
float GetErr(TString cut, vector<pair<TString,float> > samples, TString err_type,TString var){
float total(0.);
float total_witherr(0.);
int i=0;
for(vector<pair<TString,float> >::iterator it = samples.begin(); it!=samples.end(); it++, i++){
total += GetIntegral(cut,it->first,("MC/"));
total_witherr += GetIntegral(cut,it->first,("MC_" + err_type));
}
float err= total - total_witherr;
if(err_type.Contains("MM")){
if((var.Contains("UP")||var.Contains("Up"))) {
if(( ( total - total_witherr)< 0.)) return fabs(err);
else return total*0.1;
}
if((var.Contains("DOWN")||var.Contains("Down")) && ( ( total - total_witherr > 0.))) return err;
else return total*0.1;
}
if((var.Contains("UP")||var.Contains("Up"))) {
if(( ( total - total_witherr)< 0.)) return fabs(err);
else return 0.;
}
if((var.Contains("DOWN")||var.Contains("Down"))){
if( ( total - total_witherr > 0.)) return err;
else return 0.;
}
return err;
}
float GetSystPercent(TString cut, TString syst, pair<vector<pair<TString,float> >,TString > samples ){
return ( 100.*(GetSyst(cut, syst,samples )/ Calculate(cut,"Normal",samples)));
}
float GetSyst(TString cut, TString syst, pair<vector<pair<TString,float> >,TString > samples ){
if(syst.Contains("Stat"))return GetStatError(cut,samples.first) ;
if(syst.Contains("Normalisation")) return GetNormErr(cut,samples.first);
if(syst.Contains("TOTAL"))return sqrt( GetStatError2(cut,samples.first)+
GetNormErr2(cut,samples.first));
return -9999.;
}
float Calculate(TString cut, TString variance, pair<vector<pair<TString,float> >,TString > samples ){
if(samples.second.Contains("Nonprompt_DoubleEG")){
if(variance.Contains("Normal")) return GetTotal(cut,samples.first) ;
if(variance.Contains("StatErr")) return GetStatError(cut,samples.first) ;
}
if(variance.Contains("Up") || variance.Contains("UP")||variance.Contains("Down") || variance.Contains("DOWN") ){
return fabs(sqrt( (GetNormErr2(cut,samples.first))));
}
if(variance.Contains("Normal")) return GetTotal(cut,samples.first) ;
if(variance.Contains("StatErr")) return GetStatError(cut,samples.first) ;
return -999999.;
}
float Error(TH1* h){
double err ;
double integral = h->IntegralAndError(0,h->GetNbinsX(),err,"");
return err;
}
void SetUpMasterConfig(string name){
// Get list of cuts to plot
ifstream master_config_name_file(name.c_str());
if(!master_config_name_file) {
cerr << "Did not find " + name + ", exiting ..." << endl;
return;
}
while(!master_config_name_file.eof()) {
string tmp;
string tmppath;
master_config_name_file >> tmp;
master_config_name_file >> tmppath;
if(tmp=="END") break;
if(tmp.find("#")!=string::npos) continue;
cout << "tmp = " << tmp << endl;
if(tmp=="mcpath") mcloc = tmppath;
if(tmp=="datapath") dataloc = tmppath;
if(tmp=="nonpromptpath") nonpromptloc = tmppath;
if(tmp=="prefix") fileprefix = tmppath;
if(tmp=="postfix") filepostfix = tmppath;
if(tmp=="plottingpath") plotloc = tmppath;
if(tmp=="cutpath") cutloc = tmppath;
if(tmp=="outputdir") path = tmppath;
if(tmp=="showdata") {
if (tmppath == "true") showdata=true;
else showdata=false;
}
if(tmp=="ylog") {
if (tmppath == "true")ylog=true;
else ylog = false;
}
if(tmp=="usenp"){
if (tmppath == "true")usenp = true;
else usenp=false;
}
if(tmp=="samples_ss"){
listofsamples_ss.push_back(tmppath);
}
if(tmp=="samples"){
listofsamples.push_back(tmppath);
}
if(tmp=="histdir") histdir = tmppath;
cutfile = cutloc;
histfile = plotloc;
}
}
void SetUpConfig(vector<pair<pair<vector<pair<TString,float> >, int >, TString > >& samples, vector<pair<pair<vector<pair<TString,float> >, int >, TString > >& samples_ss, vector<string>& cut_label){
/// colours of histograms
int tcol(0), zzcol(0), fcol(0), ttcol(0), zcol(0), wzcol(0), sscol(0), wwcol(0), wcol(0), ttvcol(0), higgscol(0), vvvcol(0), vvcol(0), vgammacol(0);
// Get list of cuts to plot
ifstream colour_name_file("Config/colour.txt");
if(!colour_name_file) {
cerr << "Did not find Config/colour.txt, exiting ..." << endl;
return;
}
while(!colour_name_file.eof()) {
string histname;
int col;
colour_name_file >> histname;
if(histname=="END") break;
colour_name_file >> col;
if(histname=="tcol") tcol =col;
if(histname=="ttcol") ttcol =col;
if(histname=="zzcol") zzcol =col;
if(histname=="fcol") fcol =col;
if(histname=="zcol") zcol =col;
if(histname=="wzcol") wzcol =col;
if(histname=="wwcol") wwcol =col;
if(histname=="wcol") wcol =col;
if(histname=="higgscol") higgscol =col;
if(histname=="ttvcol") ttvcol = col;
}
/// Setup list of samples: grouped into different processes
vector<pair<TString,float> > top = InitSample("top");
vector<pair<TString,float> > vv = InitSample("vv");
// Zjet
vector<pair<TString,float> > zlow = InitSample("dylow_");
vector<pair<TString,float> > zhigh = InitSample("dyhigh_");
vector<pair<TString,float> > w = InitSample("wjet_");
vector<pair<TString,float> > other = InitSample("other_");
/// QCD samples
vector<pair<TString,float> > QCD = InitSample("qcd");
/// ALL same sign processes
vector<pair<TString,float> > prompt = InitSample("prompt");
/// NP is nonprompt
vector<pair<TString,float> > np;
np.push_back(make_pair("nonprompt_DoubleEG",0.34));
vector<pair<TString,float> > cf;
cf.push_back(make_pair("chargeflip",0.12));
for( unsigned int i = 0; i < listofsamples.size(); i++){
cout << listofsamples.at(i) << endl;
if(listofsamples.at(i) =="other")samples.push_back(make_pair(make_pair(other,zzcol),"Other"));
if(listofsamples.at(i) =="vv")samples.push_back(make_pair(make_pair(vv,zzcol),"Diboson"));
if(listofsamples.at(i) =="dylow")samples.push_back(make_pair(make_pair(zlow,tcol),"DY#rightarrow ll; 10 < m(ll) < 50"));
if(listofsamples.at(i) =="dyhigh")samples.push_back(make_pair(make_pair(zhigh,zcol),"DY#rightarrow ll; m(ll) > 50"));
if(listofsamples.at(i) =="top")samples.push_back(make_pair(make_pair(top,ttcol),"t#bar{t},t/#bar{t},t/#bar{t}W,t#bar{t}V"));
if(listofsamples.at(i) =="wjets")samples.push_back(make_pair(make_pair(w,wcol),"Wjets"));
if(listofsamples.at(i) =="prompt")samples.push_back(make_pair(make_pair(prompt,vvcol),"Prompt Background"));
if(listofsamples.at(i) =="qcd")samples.push_back(make_pair(make_pair(QCD,fcol),"QCD"));
if(listofsamples.at(i) =="nonprompt_DoubleEG")samples.push_back(make_pair(make_pair(np,fcol),"Misid. Lepton Background"));
if(listofsamples.at(i) =="chargeflip")samples.push_back(make_pair(make_pair(cf,zcol),"Mismeas. Charge Background"));
}
for( unsigned int i = 0; i < listofsamples_ss.size(); i++){
if(listofsamples_ss.at(i) =="vv")samples_ss.push_back(make_pair(make_pair(vv,zzcol),"WZ,ZZ,WW"));
if(listofsamples_ss.at(i) =="dylow")samples_ss.push_back(make_pair(make_pair(zlow,tcol),"DY#rightarrow ll; 10 < m(ll) < 50"));
if(listofsamples_ss.at(i) =="dyhigh")samples_ss.push_back(make_pair(make_pair(zhigh,zcol),"DY#rightarrow ll; m(ll) > 50"));
if(listofsamples_ss.at(i) =="top")samples_ss.push_back(make_pair(make_pair(top,ttcol),"t#bar{t},t/#bar{t},t/#bar{t}W,t#bar{t}V"));
if(listofsamples_ss.at(i) =="wjets")samples_ss.push_back(make_pair(make_pair(w,wcol),"Wjets"));
if(listofsamples_ss.at(i) =="prompt")samples_ss.push_back(make_pair(make_pair(prompt,vvcol),"Prompt Background"));
if(listofsamples_ss.at(i) =="qcd")samples_ss.push_back(make_pair(make_pair(QCD,fcol),"QCD"));
if(listofsamples_ss.at(i) =="nonprompt_DoubleEG")samples_ss.push_back(make_pair(make_pair(np,fcol),"Misid. Lepton Background"));
if(listofsamples_ss.at(i) =="chargeflip")samples_ss.push_back(make_pair(make_pair(cf,zcol),"Mismeas. Charge Background"));
}
///// Fix cut flow code
caption="Number of events containing two prompt electrons and two jets, with Z peak removed, in 19 fb$^{-1}$ of CMS data at 8~TeV";
hist = "/h_Nelectrons";
columnname="";
return;
}
TCanvas* CompDataMC(TH1* hdata, vector<THStack*> mcstack,TH1* hup, TH1* hdown,TH1* hup_nostat,TLegend* legend, const string hname, const int rebin, double xmin, double xmax,double ymin, double ymax,string path , string folder, bool logy, bool usedata, TString channel) {
ymax = GetMaximum(hdata, hup, ylog, hname, xmax);
string cname;
if(hdata) cname= string("c_") + hdata->GetName();
else cname = string("c_") + ((TNamed*)mcstack.at(0)->GetHists()->First())->GetName();
string label_plot_type = "";
//Create Canvases
unsigned int outputWidth = 1600;
unsigned int outputHeight = 1200;
TCanvas* canvas = new TCanvas((cname+ label_plot_type).c_str(), (cname+label_plot_type).c_str(), outputWidth,outputHeight);
TCanvas* canvas_log = new TCanvas((cname+ label_plot_type+"log").c_str(), (cname+label_plot_type+"log").c_str(), outputWidth,outputHeight);
// references for T, B, L, R
float T = 0.08*outputHeight;
float B = 0.15*outputHeight;
float L = 0.17*outputWidth;
float R = 0.04*outputWidth;
canvas->SetFillColor(0);
canvas->SetBorderMode(0);
canvas->SetFrameFillStyle(0);
canvas->SetFrameBorderMode(0);
canvas->SetLeftMargin( L/outputWidth );
canvas->SetRightMargin( R/outputWidth );
canvas->SetTopMargin( T/outputHeight );
canvas->SetBottomMargin( B/outputHeight );
canvas->SetTickx(0);
canvas->SetTicky(0);
std::string title=canvas->GetName();
std::string tpdf = "/home/jalmond/WebPlots/"+ path + "/histograms/"+folder+"/"+title+".png";
std::string tlogpdf = "/home/jalmond/WebPlots/"+ path + "/histograms/"+folder+"/"+title+"_log.png";
///#################### Standard plot
if(!TString(hname).Contains("Tri")) {
//if(!TString(hname).Contains("SSE")) {
if(TString(hname).Contains("llmass")){canvas_log->SetLogy();canvas->SetLogy();}
if(TString(hname).Contains("LeptonPt")){canvas_log->SetLogy();canvas->SetLogy();}
//}
}
canvas->cd();
//// %%%%%%%%%% TOP HALF OF PLOT %%%%%%%%%%%%%%%%%%
TH1* h_nominal = MakeSumHist2(mcstack.at(0));
SetNomBinError(h_nominal, hup, hdown);
hdata->SetLineColor(kBlack);
// draw data hist to get axis settings
hdata->GetYaxis()->SetTitleOffset(1.5);
hdata->Draw("p9hist");
TLatex label;
label.SetTextSize(0.04);
label.SetTextColor(2);
label.SetTextFont(42);
label.SetNDC();
label.SetTextColor(1);
// //# label.DrawLatex(0.6 ,0.34,"High Mass Region");
// label.DrawLatex(0.6 ,0.4,"Nvtx reweighted");
//return canvas;
mcstack.at(0)->Draw("HIST9same");
// draw axis on same canvas
hdata->Draw("axis same");
vector<float> err_up_tmp;
vector<float> err_down_tmp;
// get graph of errors for data., Set error 1.8 for 0 entry bins
const double alpha = 1 - 0.6827;
TGraphAsymmErrors * g = new TGraphAsymmErrors(hdata);
for (int i = 0; i < g->GetN(); ++i) {
int N = g->GetY()[i];
double L = (N==0) ? 0 : (ROOT::Math::gamma_quantile(alpha/2,N,1.));
double U = (N==0) ? ( ROOT::Math::gamma_quantile_c(alpha,N+1,1) ) :
( ROOT::Math::gamma_quantile_c(alpha/2,N+1,1) );
if ( N!=0 ) {
g->SetPointEYlow(i, N-L );
g->SetPointEXlow(i, 0);
g->SetPointEYhigh(i, U-N );
g->SetPointEXhigh(i, 0);
err_down_tmp.push_back(N-L);
err_up_tmp.push_back(U-N);
}
else {
g->SetPointEYlow(i, 0.1);
g->SetPointEXlow(i, 0.);
g->SetPointEYhigh(i, 1.8);
g->SetPointEXhigh(i, 0.);
err_down_tmp.push_back(0.);
err_up_tmp.push_back(1.8);
}
}
gPad->Update();
g->SetLineWidth(2.0);
g->SetMarkerSize(0.);
g->Draw(" p0" );
//return canvas;
//hdata->GetYaxis()->SetRangeUser(0.01, ymax*10.);
hdata->SetMarkerStyle(20);
hdata->SetMarkerSize(1.6);
hdata->SetLineWidth(2.);
hdata->Draw( ("same9p9hist"));
legend->Draw();
//return canvas;
CMS_lumi( canvas, 4, 11 );
//return canvas;
canvas->Update();
canvas->RedrawAxis();
canvas->Print(tpdf.c_str(), ".png");
//// %%%%%%%%%% PRINT ON LOG
canvas_log->cd();
canvas_log->SetLogy();
gPad->SetLogz(1);
//// %%%%%%%%%% TOP HALF OF PLOT %%%%%%%%%%%%%%%%%%
float scale_for_log = 1.;
if(!ylog){
ymax = GetMaximum(hdata, hup, !ylog, hname, xmax);
hdata->GetYaxis()->SetRangeUser(0.01, ymax*scale_for_log);
}
hdata->GetYaxis()->SetTitleOffset(1.6);
hdata->Draw("p9hist");
mcstack.at(0)->Draw("9HIST same");
hdata->Draw("9samep9hist");
hdata->Draw("axis same");
gPad->Update();
g->Draw(" p0" );
legend->Draw();
/// Make significance hist
TH1* h_significance=(TH1F*)hdata->Clone("sig");
TH1* h_divup=(TH1F*)hup->Clone("divup");
TH1* h_divdown=(TH1F*)hdown->Clone("divdown");
TH1F* hdev = (TH1F*)hdata->Clone("hdev");
TH1F* hdev_err = (TH1F*)hdata->Clone("hdev_err");
TH1F* hdev_err_stat = (TH1F*)hdata->Clone("hdev_err_stat");
TH1* errorbandratio = (TH1*)h_nominal->Clone("AAA");
hdata->GetXaxis()->SetLabelSize(0.); ///
hdata->GetXaxis()->SetTitle("");
h_divup->Divide(h_nominal);
h_divdown->Divide(h_nominal);
// How large fraction that will be taken up by the data/MC ratio part
double FIGURE2_RATIO = 0.35;
double SUBFIGURE_MARGIN = 0.15;
canvas_log->SetBottomMargin(FIGURE2_RATIO);
TPad *p = new TPad( "p_test", "", 0, 0, 1, 1.0 - SUBFIGURE_MARGIN, 0, 0, 0); // create new pad, fullsize to have equal font-sizes in both plots
p->SetTopMargin(1-FIGURE2_RATIO); // top-boundary (should be 1 - thePad->GetBottomMargin() )
p->SetFillStyle(0); // needs to be transparent
p->Draw();
p->cd();
Double_t *staterror;
for (Int_t i=1;i<=hdev->GetNbinsX()+1;i++) {
hdev_err->SetBinContent(i, 1.0);
if(h_nominal->GetBinContent(i) > 0 && hdev->GetBinContent(i) > 0){
hdev_err->SetBinError(i, (hup_nostat->GetBinContent(i)- h_nominal->GetBinContent(i))/h_nominal->GetBinContent(i) );
}
else{
hdev_err->SetBinError(i, 0.0);
}
}
for (Int_t i=1;i<=hdev->GetNbinsX()+1;i++) {
hdev_err_stat->SetBinContent(i, 1.0);
if(h_nominal->GetBinContent(i) > 0 && hdev->GetBinContent(i) > 0){
hdev_err_stat->SetBinError(i, (hup->GetBinContent(i)-h_nominal->GetBinContent(i))/h_nominal->GetBinContent(i) );
}
else{
hdev_err_stat->SetBinError(i, 0.0);
}
}
for (Int_t i=1;i<=hdev->GetNbinsX()+1;i++) {
if(h_nominal->GetBinContent(i) > 0 && hdev->GetBinContent(i) > 0){
hdev->SetBinContent(i, hdev->GetBinContent(i)/ h_nominal->GetBinContent(i));
//hdev->SetBinContent(i, h_nominal->GetBinContent(i)/ h_nominal->GetBinContent(i));
hdev->SetBinError(i, 0.01);
}
else {
hdev->SetBinContent(i, -99);
hdev->SetBinError(i, 0.);
}
}
/// set errors for datamc plot
TGraphAsymmErrors * gratio = new TGraphAsymmErrors(hdev);
for (int i = 0; i < gratio->GetN(); ++i) {
if(err_down_tmp.at(i) !=0.) {
gratio->SetPointEYlow(i, err_down_tmp.at(i) / h_nominal->GetBinContent(i+1) );
gratio->SetPointEXlow(i, 0);
gratio->SetPointEYhigh(i, err_up_tmp.at(i) /h_nominal->GetBinContent(i+1));
gratio->SetPointEXhigh(i, 0);
}
else{
gratio->SetPointEYlow(i, 0);
gratio->SetPointEXlow(i, 0);
gratio->SetPointEYhigh(i, 1.8 / h_nominal->GetBinContent(i+1));
gratio->SetPointEXhigh(i, 0);
}
}
//////////// Plot all
hdev->GetYaxis()->SetTitle( "#frac{Data}{MC}" );
hdev->GetYaxis()->SetRangeUser(0.6,+1.4);
hdev->GetYaxis()->SetNdivisions(9);
hdev->SetMarkerStyle(20);
//hdev->SetMarkerSize(2.3);
hdev_err_stat->SetMarkerSize(0.);
hdev_err->SetMarkerSize(0.);
hdev->SetLineColor(kBlack);
hdev_err->SetFillColor(kRed);
hdev_err->SetLineColor(kRed);
hdev_err->SetFillStyle(3444);
hdev_err_stat->SetFillColor(kOrange-9);
hdev_err_stat->SetLineColor(kOrange-9);
hdev->Draw("phist");
hdev_err_stat->Draw("sameE4");
hdev_err->Draw("sameE4");
gratio->SetLineWidth(2.0);
gratio->SetMarkerSize(0.);
gratio->Draw(" p0" );
hdev->Draw("same p hist");
TLine *devz = new TLine(hdev->GetBinLowEdge(hdev->GetXaxis()->GetFirst()),1.0,hdev->GetBinLowEdge(hdev->GetXaxis()->GetLast()+1),1.0 );
devz->SetLineWidth(1);
devz->SetLineStyle(1);
devz->Draw("SAME");
CMS_lumi( canvas_log, 4, 11 );
canvas_log->Update();
canvas_log->RedrawAxis();
canvas_log->Print(tlogpdf.c_str(), ".png");
gPad->RedrawAxis();
return canvas;
}
TH1* MakeSumHist2(THStack* thestack){
TH1* hsum=0;
TList* list = thestack->GetHists();
TIter it(list, true);
TObject* obj=0;
while( (obj = it.Next()) ) {
TH1* h = dynamic_cast<TH1*>(obj);
if(!hsum) hsum = (TH1*)h->Clone( (string(h->GetName()) + "_sum").c_str() );
else {
hsum->Add(h, 1.0);
}
}//hist loop
return hsum;
}
void SetNomBinError(TH1* hnom, TH1* hup, TH1* hdown){
for(int i=1; i < hnom->GetNbinsX()+1; i++){
float err1 = fabs(hnom->GetBinContent(i)- hup->GetBinContent(i));
float err2 = fabs(hnom->GetBinContent(i)- hdown->GetBinContent(i));
if(err1 > err2 ) hnom->SetBinError(i, err1);
if(err2 > err1 ) hnom->SetBinError(i, err2);
}
return;
}
TH1* MakeErrorBand(TH1* hnom, TH1* hup, TH1* hdown){
TH1* errorband = (TH1*)hnom->Clone("aa");
for(int i=1; i < errorband->GetNbinsX()+1; i++){
float bin_content = (hup->GetBinContent(i)+ hdown->GetBinContent(i))/2.;
float bin_error = (hup->GetBinContent(i)- hdown->GetBinContent(i))/2.;
errorband->SetBinContent(i,bin_content);
errorband->SetBinError(i,bin_error);
}
errorband->SetFillStyle(3444);
errorband->SetFillColor(kBlue-8);
errorband->SetMarkerSize(0);
errorband->SetMarkerStyle(0);
errorband->SetLineColor(kWhite);
errorband->Draw("E2Same");
return errorband;
}
void MakeLabel(float rhcol_x, float rhcol_y){
TLatex label;
label.SetTextSize(0.04);
label.SetTextColor(2);
label.SetTextFont(42);
label.SetNDC();
label.SetTextColor(1);
label.DrawLatex(rhcol_x,rhcol_y,"#int L dt = 20.4 fb^{-1}");
label.DrawLatex(rhcol_x + 0.2,rhcol_y ,"#sqrt{s}= 8 TeV");
label.SetTextSize(0.045);
label.DrawLatex(rhcol_x+0.115, rhcol_y + 0.09,"Work In Progress");
label.SetTextFont(72);
label.DrawLatex(rhcol_x, rhcol_y + 0.09,"CMS");
return;
}
void
CMS_lumi( TPad* pad, int iPeriod, int iPosX )
{
bool outOfFrame = false;
if( iPosX/10==0 )
{
outOfFrame = true;
}
int alignY_=3;
int alignX_=2;
if( iPosX/10==0 ) alignX_=1;
if( iPosX==0 ) alignY_=1;
if( iPosX/10==1 ) alignX_=1;
if( iPosX/10==2 ) alignX_=2;
if( iPosX/10==3 ) alignX_=3;
int align_ = 10*alignX_ + alignY_;
float H = pad->GetWh();
float W = pad->GetWw();
float l = pad->GetLeftMargin();
float t = pad->GetTopMargin();
float r = pad->GetRightMargin();
float b = pad->GetBottomMargin();
float e = 0.025;
pad->cd();
TString lumiText;
if( iPeriod==1 )
{
lumiText += lumi_7TeV;
lumiText += " (7 TeV)";
}
else if ( iPeriod==2 )
{
lumiText += lumi_8TeV;
lumiText += " (8 TeV)";
}
else if( iPeriod==3 )
{
lumiText = lumi_8TeV;
lumiText += " (8 TeV)";
lumiText += " + ";
lumiText += lumi_7TeV;
lumiText += " (7 TeV)";
}
else if ( iPeriod==4 )
{
lumiText += lumi_13TeV_2016_eg_BtoG;
lumiText += " (13 TeV)";
}
else if ( iPeriod==7 )
{
if( outOfFrame ) lumiText += "#scale[0.85]{";
lumiText += lumi_13TeV_2016_eg_BtoG;
lumiText += " (13 TeV)";
lumiText += " + ";
lumiText += lumi_8TeV;
lumiText += " (8 TeV)";
lumiText += " + ";
lumiText += lumi_7TeV;
lumiText += " (7 TeV)";
if( outOfFrame) lumiText += "}";
}
else if ( iPeriod==12 )
{
lumiText += "8 TeV";
}
TLatex latex;
latex.SetNDC();
latex.SetTextAngle(0);
latex.SetTextColor(kBlack);
float extraTextSize = extraOverCmsTextSize*cmsTextSize;
latex.SetTextFont(42);
latex.SetTextAlign(31);
latex.SetTextSize(lumiTextSize*t);
latex.DrawLatex(1-r,1-t+lumiTextOffset*t,lumiText);
if( outOfFrame )
{
latex.SetTextFont(cmsTextFont);
latex.SetTextAlign(11);
latex.SetTextSize(cmsTextSize*t);
latex.DrawLatex(l,1-t+lumiTextOffset*t,cmsText);
}
pad->cd();
// writeExtraText=true;
float posX_;
if( iPosX%10<=1 )
{
posX_ = l + relPosX*(1-l-r);
}
else if( iPosX%10==2 )
{
posX_ = l + 0.5*(1-l-r);
}
else if( iPosX%10==3 )
{
posX_ = 1-r - relPosX*(1-l-r);
}
float posY_ = 1-t - relPosY*(1-t-b);
if( !outOfFrame )
{
if( drawLogo )
{
posX_ = l + 0.045*(1-l-r)*W/H;
posY_ = 1-t - 0.045*(1-t-b);
float xl_0 = posX_;
float yl_0 = posY_ - 0.15;
float xl_1 = posX_ + 0.15*H/W;
float yl_1 = posY_;
TASImage* CMS_logo = new TASImage("CMS-BW-label.png");
TPad* pad_logo = new TPad("logo","logo", xl_0, yl_0, xl_1, yl_1 );
pad_logo->Draw();
pad_logo->cd();
CMS_logo->Draw("X");
pad_logo->Modified();
pad->cd();
}
else
{
latex.SetTextFont(cmsTextFont);
latex.SetTextSize(cmsTextSize*t);
latex.SetTextAlign(align_);
latex.DrawLatex(posX_, posY_, cmsText);
if( writeExtraText )
{
latex.SetTextFont(extraTextFont);
latex.SetTextAlign(align_);
latex.SetTextSize(extraTextSize*t);
latex.DrawLatex(posX_, posY_- relExtraDY*cmsTextSize*t, extraText);
}
}
}
else if( writeExtraText )
{
if( iPosX==0)
{
posX_ = l + relPosX*(1-l-r);
posY_ = 1-t+lumiTextOffset*t;
}
latex.SetTextFont(extraTextFont);
latex.SetTextSize(extraTextSize*t);
latex.SetTextAlign(align_);
latex.DrawLatex(posX_, posY_, extraText);
}
return;
}
| [
"jalmond@cern.ch"
] | jalmond@cern.ch |
2c3ccc7bf4c9f974bab9123f48493ea15c297984 | 6e46da75306b7fbec2d9e83da71a23669a89edc5 | /library/source/renderer/backend/vulkan/render_tasks/upload_scene_render_task.cpp | fcdc3275f04b8649f9ef7d56b8d3520d8fb51537 | [
"BSL-1.0"
] | permissive | acdemiralp/makina-old | a5d09a4a7a7f1c7c3b2ae290efa0d8e3613538e9 | 8246d6683bb4a7f1b40a31f24a21dc8b1ff736ba | refs/heads/master | 2023-05-28T18:52:43.089816 | 2018-07-01T17:29:31 | 2018-07-01T17:29:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 19,993 | cpp | #include <makina/renderer/backend/vulkan/render_tasks/upload_scene_render_task.hpp>
#include <makina/renderer/backend/vulkan/context.hpp>
#include <makina/renderer/light.hpp>
#include <makina/renderer/mesh_render.hpp>
#include <makina/renderer/projection.hpp>
#include <makina/renderer/transform.hpp>
#include <makina/resources/mesh.hpp>
#include <makina/resources/phong_material.hpp>
#include <makina/resources/physically_based_material.hpp>
namespace mak
{
namespace vulkan
{
void load_image(mak::image* source, std::shared_ptr<vkhlf::Buffer> intermediate, std::shared_ptr<vkhlf::Image> target, std::size_t offset, const bool single_channel = false)
{
auto command_buffer = vulkan::context().command_pool->allocateCommandBuffer();
command_buffer->begin ();
intermediate ->update<std::uint8_t>(0, {static_cast<std::uint32_t>(source->pixels().size), source->pixels().data}, command_buffer);
command_buffer->copyBufferToImage (intermediate, target, vk::ImageLayout::eTransferDstOptimal, vk::BufferImageCopy(0, 0, 0, vk::ImageSubresourceLayers(vk::ImageAspectFlagBits::eColor, 0, 0, 0), vk::Offset3D(0, 0, offset), vk::Extent3D(source->dimensions()[0], source->dimensions()[1], 1)));
command_buffer->end ();
vkhlf::submitAndWait (vulkan::context().graphics_queue, command_buffer);
}
fg::render_task<upload_scene_task_data>* add_upload_scene_render_task(renderer* framegraph)
{
// Shader vertex type.
struct _vertex
{
glm::vec3 position ;
glm::vec3 normal ;
glm::vec3 texture_coordinates;
glm::uvec2 instance_attributes;
};
// Shader types with std430 alignment.
struct _transform
{
glm::mat4 model ;
};
struct _phong_material
{
glm::uvec4 use_texture ; // ambient - diffuse - specular - unused
glm::vec4 ambient ; // w is unused.
glm::vec4 diffuse ; // w is unused.
glm::vec4 specular ; // w is shininess.
glm::u64vec4 textures ; // ambient - diffuse - specular - unused
};
struct _physically_based_material
{
glm::uvec4 use_texture ; // albedo - metallicity - roughness - normal
glm::uvec4 use_texture_2; // ambient occlusion - unused - unused - unused
glm::vec4 albedo ; // w is unused.
glm::vec4 properties ; // metallicity - roughness - unused - unused
glm::u64vec4 textures ; // albedo - metallicity - roughness - normal
glm::u64vec4 textures_2 ; // ambient occlusion - unused - unused - unused
};
struct _camera
{
glm::mat4 view ;
glm::mat4 projection ;
};
struct _light
{
glm::uvec4 type ; // y, z, w are unused.
glm::vec4 color ; // w is unused.
glm::vec4 properties ; // intensity - range - inner spot - outer spot
glm::vec4 position ; // w is unused.
glm::vec4 direction ; // w is unused.
};
const glm::uvec3 texture_size {2048, 2048, 64};
const auto retained_vertices = framegraph->add_retained_resource<buffer_description , std::shared_ptr<vkhlf::Buffer>> ("Scene Vertices" , buffer_description{vk::DeviceSize(128e+6), vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eVertexBuffer });
const auto retained_indices = framegraph->add_retained_resource<buffer_description , std::shared_ptr<vkhlf::Buffer>> ("Scene Indices" , buffer_description{vk::DeviceSize( 64e+6), vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eIndexBuffer });
const auto retained_transforms = framegraph->add_retained_resource<buffer_description , std::shared_ptr<vkhlf::Buffer>> ("Scene Transforms" , buffer_description{vk::DeviceSize( 16e+6), vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eStorageBuffer });
const auto retained_materials = framegraph->add_retained_resource<buffer_description , std::shared_ptr<vkhlf::Buffer>> ("Scene Materials" , buffer_description{vk::DeviceSize( 16e+6), vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eStorageBuffer });
const auto retained_cameras = framegraph->add_retained_resource<buffer_description , std::shared_ptr<vkhlf::Buffer>> ("Scene Cameras" , buffer_description{vk::DeviceSize( 16e+6), vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eStorageBuffer });
const auto retained_lights = framegraph->add_retained_resource<buffer_description , std::shared_ptr<vkhlf::Buffer>> ("Scene Lights" , buffer_description{vk::DeviceSize( 16e+6), vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eStorageBuffer });
const auto retained_draw_calls = framegraph->add_retained_resource<buffer_description , std::shared_ptr<vkhlf::Buffer>> ("Scene Draw Calls" , buffer_description{vk::DeviceSize( 16e+6), vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eIndirectBuffer});
// Totals to 128 * 1 + 64 * 1 + 16 * 5 = 272 MB of GPU memory for buffers.
const auto retained_images = framegraph->add_retained_resource<image_description , std::shared_ptr<vkhlf::Image>> ("Scene Images" , image_description {vk::ImageType::e3D , vk::Extent3D(texture_size[0], texture_size[1], texture_size[2]), vk::Format::eR8G8B8A8Unorm, vk::ImageUsageFlagBits::eTransferDst | vk::ImageUsageFlagBits::eSampled});
const auto retained_sampler = framegraph->add_retained_resource<sampler_description, std::shared_ptr<vkhlf::Sampler>>("Scene Sampler" , sampler_description{vk::Filter::eLinear, vk::Filter::eLinear});
// Totals to 64 * 16.77 = 1073 MB of GPU memory for textures.
const auto retained_parameter_map = framegraph->add_retained_resource<parameter_map::description, parameter_map> ("Scene Parameter Map", parameter_map::description());
return framegraph->add_render_task<upload_scene_task_data>(
"Upload Scene Pass",
[&] ( upload_scene_task_data& data, fg::render_task_builder& builder)
{
data.intermediates = builder.create<buffer_resource> ("Scene Intermediates", buffer_description{vk::DeviceSize(32e+6), vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent});
data.vertices = builder.write <buffer_resource> (retained_vertices );
data.indices = builder.write <buffer_resource> (retained_indices );
data.transforms = builder.write <buffer_resource> (retained_transforms );
data.materials = builder.write <buffer_resource> (retained_materials );
data.cameras = builder.write <buffer_resource> (retained_cameras );
data.lights = builder.write <buffer_resource> (retained_lights );
data.draw_calls = builder.write <buffer_resource> (retained_draw_calls );
data.images = builder.write <image_resource> (retained_images );
data.sampler = builder.write <sampler_resource> (retained_sampler );
data.parameter_map = builder.write <parameter_map_resource>(retained_parameter_map);
},
[=] (const upload_scene_task_data& data)
{
auto scene = framegraph->scene_cache();
auto mesh_render_entities = scene->entities<transform, mesh_render>();
auto light_entities = scene->entities<transform, light> ();
auto camera_entities = scene->entities<transform, projection> ();
auto vertices = std::vector<_vertex> ();
auto indices = std::vector<std::uint32_t> ();
auto transforms = std::vector<_transform> ();
auto pbr_materials = std::vector<_physically_based_material> ();
auto phong_materials = std::vector<_phong_material> ();
auto cameras = std::vector<_camera> ();
auto lights = std::vector<_light> ();
auto draw_calls = std::vector<vk::DrawIndexedIndirectCommand>();
std::uint32_t texture_offset = 0;
std::uint32_t first_index_offset = 0;
std::int32_t base_vertex_offset = 0;
for (auto i = 0; i < mesh_render_entities.size(); ++i)
{
const auto& entity = mesh_render_entities[i];
const auto transform = entity->component<mak::transform> ();
const auto mesh_render = entity->component<mak::mesh_render>();
glm::vec3 texture_coordinate_scale(1.0f);
auto pbr_material = dynamic_cast<mak::physically_based_material*>(mesh_render->material);
if (pbr_material)
{
std::optional<std::uint32_t> albedo_offset, metallicity_offset, roughness_offset, normal_offset, ambient_occlusion_offset;
if (pbr_material->albedo_image)
{
load_image(pbr_material->albedo_image .get(), *data.intermediates->actual(), *data.images->actual(), texture_offset);
albedo_offset = texture_offset++;
}
if (pbr_material->metallicity_image)
{
load_image(pbr_material->metallicity_image .get(), *data.intermediates->actual(), *data.images->actual(), texture_offset, true);
metallicity_offset = texture_offset++;
}
if (pbr_material->roughness_image)
{
load_image(pbr_material->roughness_image .get(), *data.intermediates->actual(), *data.images->actual(), texture_offset, true);
roughness_offset = texture_offset++;
}
if (pbr_material->normal_image)
{
load_image(pbr_material->normal_image .get(), *data.intermediates->actual(), *data.images->actual(), texture_offset);
normal_offset = texture_offset++;
}
if (pbr_material->ambient_occlusion_image)
{
load_image(pbr_material->ambient_occlusion_image.get(), *data.intermediates->actual(), *data.images->actual(), texture_offset);
ambient_occlusion_offset = texture_offset++;
}
pbr_materials.push_back(_physically_based_material {
glm::uvec4
{
static_cast<std::uint32_t>(albedo_offset .has_value()),
static_cast<std::uint32_t>(metallicity_offset .has_value()),
static_cast<std::uint32_t>(roughness_offset .has_value()),
static_cast<std::uint32_t>(normal_offset .has_value())
},
glm::uvec4
{
static_cast<std::uint32_t>(ambient_occlusion_offset.has_value()), 0, 0, 0
},
glm::vec4 (pbr_material->albedo, 0.0f),
glm::vec4 (pbr_material->metallicity, pbr_material->roughness, 0.0f, 0.0f),
glm::uvec4(
albedo_offset ? *albedo_offset : 0,
metallicity_offset ? *metallicity_offset : 0,
roughness_offset ? *roughness_offset : 0,
normal_offset ? *normal_offset : 0),
glm::uvec4(
ambient_occlusion_offset ? *ambient_occlusion_offset : 0, 0, 0, 0)
});
if (pbr_material->albedo_image )
texture_coordinate_scale = glm::vec3(float(pbr_material->albedo_image ->dimensions()[0]) / texture_size[0], float(pbr_material->albedo_image ->dimensions()[1]) / texture_size[1], 1.0f);
else if (pbr_material->metallicity_image)
texture_coordinate_scale = glm::vec3(float(pbr_material->metallicity_image ->dimensions()[0]) / texture_size[0], float(pbr_material->metallicity_image ->dimensions()[1]) / texture_size[1], 1.0f);
else if (pbr_material->roughness_image)
texture_coordinate_scale = glm::vec3(float(pbr_material->roughness_image ->dimensions()[0]) / texture_size[0], float(pbr_material->roughness_image ->dimensions()[1]) / texture_size[1], 1.0f);
else if (pbr_material->normal_image)
texture_coordinate_scale = glm::vec3(float(pbr_material->normal_image ->dimensions()[0]) / texture_size[0], float(pbr_material->normal_image ->dimensions()[1]) / texture_size[1], 1.0f);
else if (pbr_material->ambient_occlusion_image)
texture_coordinate_scale = glm::vec3(float(pbr_material->ambient_occlusion_image->dimensions()[0]) / texture_size[0], float(pbr_material->ambient_occlusion_image->dimensions()[1]) / texture_size[1], 1.0f);
}
auto phong_material = dynamic_cast<mak::phong_material*>(mesh_render->material);
if (phong_material)
{
std::optional<std::uint32_t> ambient_offset, diffuse_offset, specular_offset;
if (phong_material->ambient_image)
{
load_image(phong_material->ambient_image .get(), *data.intermediates->actual(), *data.images->actual(), texture_offset);
ambient_offset = texture_offset++;
}
if (phong_material->diffuse_image)
{
load_image(phong_material->diffuse_image .get(), *data.intermediates->actual(), *data.images->actual(), texture_offset);
diffuse_offset = texture_offset++;
}
if (phong_material->specular_image)
{
load_image(phong_material->specular_image.get(), *data.intermediates->actual(), *data.images->actual(), texture_offset);
specular_offset = texture_offset++;
}
phong_materials .push_back(_phong_material {
glm::uvec4
{
static_cast<std::uint32_t>(ambient_offset .has_value()),
static_cast<std::uint32_t>(diffuse_offset .has_value()),
static_cast<std::uint32_t>(specular_offset.has_value()),
0
},
glm::vec4 (phong_material->ambient , 0.0f),
glm::vec4 (phong_material->diffuse , 0.0f),
glm::vec4 (phong_material->specular, phong_material->shininess),
glm::u64vec4(
ambient_offset ? *ambient_offset : 0,
diffuse_offset ? *diffuse_offset : 0,
specular_offset ? *specular_offset : 0,
0)
});
if (phong_material->ambient_image )
texture_coordinate_scale = glm::vec3(float(phong_material->ambient_image ->dimensions()[0]) / texture_size[0], float(phong_material->ambient_image ->dimensions()[1]) / texture_size[1], 1.0f);
else if (phong_material->diffuse_image )
texture_coordinate_scale = glm::vec3(float(phong_material->diffuse_image ->dimensions()[0]) / texture_size[0], float(phong_material->diffuse_image ->dimensions()[1]) / texture_size[1], 1.0f);
else if (phong_material->specular_image)
texture_coordinate_scale = glm::vec3(float(phong_material->specular_image->dimensions()[0]) / texture_size[0], float(phong_material->specular_image->dimensions()[1]) / texture_size[1], 1.0f);
}
transforms.push_back(_transform {transform->matrix(true)});
const auto& mesh_vertices = mesh_render->mesh->vertices ;
const auto& mesh_normals = mesh_render->mesh->normals ;
const auto& mesh_texture_coordinates = mesh_render->mesh->texture_coordinates;
const auto& mesh_indices = mesh_render->mesh->indices ;
for(auto j = 0; j < mesh_vertices.size(); ++j)
vertices.push_back(_vertex{glm::vec4(mesh_vertices[j], 1.0f), glm::vec4(mesh_normals[j], 0.0f), texture_coordinate_scale * mesh_texture_coordinates[j], {i, i}});
indices.insert(indices.end(), mesh_indices.begin(), mesh_indices.end());
draw_calls.push_back(vk::DrawIndexedIndirectCommand
{
static_cast<std::uint32_t>(indices.size()),
1u,
first_index_offset,
base_vertex_offset,
static_cast<std::uint32_t>(i)
});
first_index_offset += static_cast<std::uint32_t>(indices .size());
base_vertex_offset += static_cast<std::uint32_t>(vertices.size());
}
for (auto& entity : camera_entities)
{
auto transform = entity->component<mak::transform> ();
auto projection = entity->component<mak::projection>();
cameras.push_back(_camera
{
inverse(transform->matrix(true)),
projection->matrix()
});
}
for (auto& entity : light_entities)
{
auto transform = entity->component<mak::transform>();
auto light = entity->component<mak::light> ();
lights.push_back(_light
{
glm::uvec4(light->type , 0, 0, 0),
glm::vec4 (light->color, 0.0f),
glm::vec4 (light->intensity, light->range, light->spot_angles[0], light->spot_angles[1]),
glm::vec4 (transform->translation(true), 0.0f),
glm::vec4 (transform->forward (true), 0.0f)
});
}
data.parameter_map->actual()->set("draw_count", draw_calls.size());
auto command_buffer = vulkan::context().command_pool->allocateCommandBuffer();
command_buffer->begin();
(*data.vertices->actual())->update<_vertex> (0, {static_cast<std::uint32_t>(vertices.size()), vertices.data()}, command_buffer);
(*data.indices ->actual())->update<std::uint32_t>(0, {static_cast<std::uint32_t>(indices .size()), indices .data()}, command_buffer);
glm::uvec4 transforms_metadata {static_cast<std::uint32_t>(transforms .size()), 0u, 0u, 0u};
glm::uvec4 materials_metadata {static_cast<std::uint32_t>(pbr_materials.size() > 0 ? pbr_materials.size() : phong_materials.size()), 0u, 0u, 0u};
glm::uvec4 cameras_metadata {static_cast<std::uint32_t>(cameras .size()), 0u, 0u, 0u};
glm::uvec4 lights_metadata {static_cast<std::uint32_t>(lights .size()), 0u, 0u, 0u};
(*data.transforms->actual())->update<glm::uvec4>(0, {1u, &transforms_metadata}, command_buffer);
(*data.materials ->actual())->update<glm::uvec4>(0, {1u, &materials_metadata }, command_buffer);
(*data.cameras ->actual())->update<glm::uvec4>(0, {1u, &cameras_metadata }, command_buffer);
(*data.lights ->actual())->update<glm::uvec4>(0, {1u, &lights_metadata }, command_buffer);
(*data.transforms ->actual())->update<_transform> (sizeof glm::vec4, {static_cast<std::uint32_t>(transforms .size()), transforms .data()}, command_buffer);
pbr_materials.size() > 0
? (*data.materials->actual())->update<_physically_based_material> (sizeof glm::vec4, {static_cast<std::uint32_t>(pbr_materials .size()), pbr_materials .data()}, command_buffer)
: (*data.materials->actual())->update<_phong_material> (sizeof glm::vec4, {static_cast<std::uint32_t>(phong_materials.size()), phong_materials.data()}, command_buffer);
(*data.cameras ->actual())->update<_camera> (sizeof glm::vec4, {static_cast<std::uint32_t>(cameras .size()), cameras .data()}, command_buffer);
(*data.lights ->actual())->update<_light> (sizeof glm::vec4, {static_cast<std::uint32_t>(lights .size()), lights .data()}, command_buffer);
(*data.draw_calls ->actual())->update<vk::DrawIndexedIndirectCommand>(0 , {static_cast<std::uint32_t>(draw_calls .size()), draw_calls .data()}, command_buffer);
command_buffer->end ();
vkhlf::submitAndWait(vulkan::context().graphics_queue, command_buffer);
});
}
}
}
| [
"demiralpali@gmail.com"
] | demiralpali@gmail.com |
e083d88041adf04e021a11895edd8ca093094b3d | 47bed47216f11afd4576f20d483a9195119f25e9 | /library.h | 3880d258d26dcd3f3ee3c323c06ec9b8f27192b6 | [] | no_license | strk123/proj1 | 1b7acbe9e84af6cb0a13a887ac0bc4c8da65fb32 | d0491748849b0e0ec1108a050a3c61ccac4e400f | refs/heads/master | 2020-04-04T19:02:49.361471 | 2018-11-05T14:41:03 | 2018-11-05T14:41:03 | 156,189,669 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 744 | h | #include <iostream>
#include <vector>
#include <string>
#include "member.h"
#include "resource.h"
using namespace std;
class library {
private:
vector<book> books;
vector<undergraduate> undergraduates;
public:
library();
void set_books(); // resource file을 읽어 초기 books에 저장
void input(); // input.dat file을 읽고 output을 생성
int set_data(string date, string resource_type, string resource_name, string operation, string member_type, string member_name); // 한 줄에 대해서 return code 결정
void output(int operation_num, int return_code); //return code에 따라서 output 생성
int day2int(string day); // 날짜 string을 int로 변경
string int2day(int day); // 날짜 int를 string으로 변경
}; | [
"strk1234@gmail.com"
] | strk1234@gmail.com |
8b94d85883975be85ac6a45d28332ee376929066 | 9532703c7c34daf1cac1d11550a0e9bc46843095 | /esp8266-weather-station-master/WorldClockDemo/WundergroundClient.h | 019dffa2a77879be4123b2854b3f74bb15ace4c4 | [
"MIT"
] | permissive | piwrks/ESP8266-OLED-Wetterstation-Weather-station | 8dd7479513e8455b5f228f4033cfebed8c6757dd | 899afd812fe9edd67ae66ea749e3a07c13def03d | refs/heads/master | 2021-01-10T06:20:31.111640 | 2017-02-13T18:58:57 | 2017-02-13T18:58:57 | 53,750,211 | 3 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 2,989 | h | /**The MIT License (MIT)
Copyright (c) 2015 by Daniel Eichhorn
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
See more at http://blog.squix.ch
*/
#pragma once
#include <JsonListener.h>
#include <JsonStreamingParser.h>
#define MAX_FORECAST_PERIODS 7
class WundergroundClient: public JsonListener {
private:
String currentKey;
String currentParent = "";
long localEpoc = 0;
int gmtOffset = 1;
long localMillisAtUpdate;
String date = "-";
boolean isMetric = true;
String currentTemp;
String weatherIcon;
String weatherText;
String humidity;
String pressure;
String precipitationToday;
void doUpdate(String url);
// forecast
boolean isForecast = false;
boolean isSimpleForecast = true;
int currentForecastPeriod;
String forecastIcon [MAX_FORECAST_PERIODS];
String forecastTitle [MAX_FORECAST_PERIODS];
String forecastLowTemp [MAX_FORECAST_PERIODS];
String forecastHighTemp [MAX_FORECAST_PERIODS];
public:
WundergroundClient(boolean isMetric);
void updateConditions(String apiKey, String country, String city);
void updateForecast(String apiKey, String country, String city);
String getHours();
String getMinutes();
String getSeconds();
String getDate();
long getCurrentEpoch();
String getCurrentTemp();
String getTodayIcon();
String getMeteoconIcon(String iconText);
String getWeatherText();
String getHumidity();
String getPressure();
String getPrecipitationToday();
String getForecastIcon(int period);
String getForecastTitle(int period);
String getForecastLowTemp(int period);
String getForecastHighTemp(int period);
virtual void whitespace(char c);
virtual void startDocument();
virtual void key(String key);
virtual void value(String value);
virtual void endArray();
virtual void endObject();
virtual void endDocument();
virtual void startArray();
virtual void startObject();
};
| [
"noreply@github.com"
] | piwrks.noreply@github.com |
648f0761910b41f411843cc7ae9abb9756f7a3a1 | e8c77866d6982b8d69131dd39be234123f41ffde | /projects/base_with_physics/levelone.h | d10885a2f9b8024b5e56f341703537f565d05fac | [] | no_license | cyber-squid/gad173-project3 | 36b27cc082817e06583ba1313a29dd6fa6b5a9b0 | 88c603b68308c89bd36b2049908e209e64310e16 | refs/heads/main | 2023-04-29T19:59:55.430797 | 2021-05-11T22:24:17 | 2021-05-11T22:24:17 | 365,833,319 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 299 | h | #pragma once
#include "scene.h"
class LevelOne : public Scene
{
public:
LevelOne();
~LevelOne();
void Load(sf::RenderWindow& window);
void Update(sf::RenderWindow& window);
void Render(sf::RenderWindow& window);
sf::Sprite* backgroundSprite;
std::string MapFileOne = "savefile.txt";
};
| [
"s.albreiki@student.saedubai.com"
] | s.albreiki@student.saedubai.com |
72852fd814a54268de2386694c3237704ac21a5e | c26ff0247f8fa98b565f2751c9764b53dd169ca8 | /src/allsem.cpp | 246dce1a5311ac8ee49d3ae7f899d3d6e8cade6f | [] | no_license | stepa997/Djordje_OS | e10d08a01e378e063e32bf59096561e132d8797b | cf18148d8ec73c781fc2d8dfa07fef5853917560 | refs/heads/master | 2023-04-10T08:24:28.673652 | 2021-04-11T19:17:38 | 2021-04-11T19:17:38 | 356,959,403 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,186 | cpp | /*
* allsem.cpp
*
* Created on: Sep 16, 2018
* Author: OS1
*/
#include "allsem.h"
int Allsem::getSize(){
return size;
}
void Allsem::put(Semaphore* s){
lock();
Elem* pom = new Elem(s);
if(head==0) head=tail=pom;
else{
tail->next=pom;
tail=pom;
}
size++;
unlock();
}
void Allsem::get(Semaphore* sem){
lock();
Elem *tek = head, *pom = 0;
while(tek->sem != sem && tek != 0){
pom = tek;
tek = tek->next;
}
if(tek == 0)
return;
else
if(tek == head)
head = head->next;
else
pom->next = tek->next;
if(tek->sem->val() < 0){ //pre nego sto se obrise moraju sve niti da se odblokiraju koje cekaju na njemu
int p = (-1)*tek->sem->val();
for(int i=0;i< p; i++)
tek->sem->signal();
}
size--;
delete tek;
unlock();
}
void Allsem::delQueue(){
lock();
Elem* pom;
while(head != 0){
pom = head;
if(pom->sem->val() < 0){ //ako je imalo blokiranih na semaforu onda se oslobode
int p = (-1)*pom->sem->val();
for(int i =0; i<p; i++)
pom->sem->signal();
delete pom;
}
head = head->next;
}
head = 0;
size = 0;
tail=0;
unlock();
}
| [
"stepa@gmail.com"
] | stepa@gmail.com |
6cf7c369c555619371e29acb1d6b32996766b6d3 | 31742fea5bdd2fa8660ce7db6d5654eec46703b0 | /Qt/Flooder2D/mainwindow.h | 8a2f2f5fe366785ac10c36003702a66506880538 | [] | no_license | gibbogle/vessel-tools | a0e039a7c25a08a3efb1f9a0522298ac43eb969e | 1e8b7c8babcc528e132ef443304e6b191d31e001 | refs/heads/master | 2021-01-15T15:52:20.412951 | 2020-09-06T15:54:34 | 2020-09-06T15:54:34 | 36,261,658 | 3 | 6 | null | null | null | null | UTF-8 | C++ | false | false | 498 | h | #ifndef MAINWINDOW_H
#define MAINWINDOW_H
#ifdef HAVE_QT5
#include <QtWidgets/QMainWindow>
#else
#include <QtGui/QMainWindow>
#endif
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
public slots:
void inFileSelecter();
void outFileSelecter();
void flooder();
private:
Ui::MainWindow *ui;
public:
QString infileName;
QString outfileName;
};
#endif // MAINWINDOW_H
| [
"g.bogle@auckland.ac.nz"
] | g.bogle@auckland.ac.nz |
b48e230b74e58352856f1169806d5681aa933cf6 | a4741e8b9c11bc66fbeda98b7d10fbe0d4abb39d | /DataMember.cpp | 8b5e03bb696a25d69d10ac736a737a67cf3d2607 | [
"MIT"
] | permissive | DrJWCain/DIA-SDK | 6bad776c056261fe9e21f03f747526c90172961f | 3e64fe45e34c5bc5553cd6ab24b9bf46cb7f46a5 | refs/heads/master | 2021-01-10T17:08:04.822333 | 2015-10-13T14:16:07 | 2015-10-13T14:16:07 | 44,179,907 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,880 | cpp | #include "stdafx.h"
#include "DataMember.h"
#include "useful.h"
DataMember::DataMember()
{
}
DataMember::DataMember(CComPtr<IDiaSymbol> pIDiaSymbol) : Symbol(pIDiaSymbol)
{
DWORD tag;
checkResult(pIDiaSymbol->get_symTag(&tag));
if(SymTagData != tag)
{
throw 0;
}
}
DataMember::DataMember(const DataMember& other) : Symbol(other.Symbol)
{
}
DataMember& DataMember::operator= (const DataMember& other)
{
if(*this == other)
return *this;
Symbol = other.Symbol;
return *this;
}
bool DataMember::operator== (const DataMember& other)
{
return Symbol == other.Symbol;
}
CComPtr<IDiaSymbol> DataMember::sym() const
{
return Symbol;
}
std::wstring DataMember::getName() const
{
return ::getName(sym());
}
bool DataMember::pointerToFunction() const
{
CComPtr<IDiaSymbol> type;
checkResult(sym()->get_type(&type));
DWORD tag;
checkResult(type->get_symTag(&tag));
if(SymTagPointerType == tag)
{
CComPtr<IDiaSymbol> pointee;
checkResult(type->get_type(&pointee));
DWORD pointeeTag;
checkResult(pointee->get_symTag(&pointeeTag));
return (SymTagFunctionType == pointeeTag);//function pointer!
}
return false;
}
std::wstring DataMember::type() const
{
std::wstring ret;
CComPtr<IDiaSymbol> type;
checkResult(sym()->get_type(&type));
if(!!type)
{
ret += expandType(type,getName());//name needed for function defs
}
return ret;
}
std::wstring DataMember::typeSpecial() const
{
std::wstring ret;
CComPtr<IDiaSymbol> type;
checkResult(sym()->get_type(&type));
if(!!type)
{
ret += expandTypeSpecial(type);
}
return ret;
}
bool DataMember::isStatic() const
{
DWORD kind;
checkResult(sym()->get_dataKind(&kind));
return DataIsGlobal == kind;
}
CV_access_e DataMember::protection() const
{
DWORD access;
checkResult(sym()->get_access(&access));
return (CV_access_e)access;
}
| [
"james.cain@quantel.com"
] | james.cain@quantel.com |
c97d518f308b371b7af1a3c9c2cb2a5f5480de1c | c711368f99932257d7f470dce4e8fc440c6e6503 | /tests/matrix_test.cpp | 7c34966fdcf3e612e1ac6e137c1f17f5bb9172dd | [
"MIT"
] | permissive | supercamel/EmbeddedToolKit | 25fb58438e493776a7dd19c37ffc3dd096518de0 | 77acf7b3f39a04b49bd25e7423374af38d517dff | refs/heads/master | 2023-02-03T16:55:17.879324 | 2023-01-30T06:41:46 | 2023-01-30T06:41:46 | 63,699,801 | 20 | 6 | null | 2018-02-26T20:35:01 | 2016-07-19T14:16:08 | C++ | UTF-8 | C++ | false | false | 2,064 | cpp | #include "matrix_test.h"
#include "out.h"
#include <etk/matrix.h>
using namespace etk;
#include <iostream>
using namespace std;
/*
#include <Eigen/Dense>
using Eigen::MatrixXd;
*/
bool matrix_addition()
{
Matrix<2,3> a(5,4,3,2,1,0);
Matrix<2,3> b(5,6,7,8,9,10);
Matrix<2,3> c;
c = a + b;
for(uint32 x = 0; x < 2; x++)
{
for(uint32 y = 0; y < 3; y++)
{
if(c(x,y) != 10)
return false;
}
}
a.set(5,6,7,8,9,10);
b.set(5,6,7,8,9,10);
c = a-b;
for(uint32 x = 0; x < 2; x++)
{
for(uint32 y = 0; y < 3; y++)
{
if(c(x,y) != 0)
return false;
}
}
return true;
}
bool matrix_rows_and_columns()
{
/*
Matrix<2,3> a(5,4,3,2,1,0);
MatrixXd b(2, 3);
b << 5,4,3,2,1,0;
for(uint32 x = 0; x < 2; x++)
{
for(uint32 y = 0; y < 3; y++)
{
if(a(x,y) != b(x,y))
return false;
}
}
*/
return true;
}
bool positive_definite()
{
cout << "Creating M" << endl;
Matrix<3,3> m(25.0f,15.0f,-5.0f,15.0f,18.0f,0.0f,-5.0f,0.0f,11.0f);
cout << m(0, 0) << endl;
out << m.to_string().c_str() << "\n";
m.invert();
out << m.to_string() << "\n";
return true;
}
bool determinant_test()
{
/*
using namespace etk;
Matrix<3,3> m;
*/
return true;
}
bool matrix_test(std::string& subtest)
{
subtest = "sub vector";
etk::Matrix<3,3> v;
v.set(0, 1, 2, 3, 4, 5, 6);
etk::Vector<3> d = v.sub_vector<3>(3);
if(d.x() != 3)
return false;
etk::Vector<16> big_vec;
etk::Matrix<3,3> small_mat(big_vec.sub_vector<9>(6));
subtest = "Matrix addition";
if(!matrix_addition())
return false;
subtest = "Rows and columns";
if(!matrix_rows_and_columns())
return false;
subtest = "positive definite";
if(!positive_definite())
return false;
subtest = "determinant";
if(!determinant_test())
return false;
return true;
}
| [
"samuel.cowen@camelsoftware.com"
] | samuel.cowen@camelsoftware.com |
b1ef9c5b2eae47cf657f34a89ab5bfa535e55162 | ba089fb37040a27d5cabf3220025e73174e59d69 | /04.chapter/02.CompB/CompB.cpp | 4d90567a04fd78256c263258e1b2b7b2d5dbb5cc | [] | no_license | goodpaperman/principle | 7de67613d2c7cef4c2ec3635e64fa68a12d9a8c1 | ffc1b20050f2cc46f942f04e324007ef699d8476 | refs/heads/master | 2020-05-30T11:04:01.631468 | 2019-06-01T04:10:10 | 2019-06-01T04:10:10 | 189,689,070 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,553 | cpp | // CompA.cpp : Defines the entry point for the DLL application.
//
#include "stdafx.h"
#include "ComponentB.h"
#include "Factory.h"
#include "Registry.h"
HMODULE g_hModule;
BOOL APIENTRY DllMain( HANDLE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
if(ul_reason_for_call == DLL_PROCESS_ATTACH)
g_hModule = (HMODULE)hModule;
return TRUE;
}
extern "C" HRESULT _stdcall DllGetClassObject(const CLSID& clsid, const IID& iid, void** ppv)
{
printf("enter CompB::DllGetClassObject\n");
if(clsid == CLSID_ComponentB)
{
CBFactory* pFactory = new CBFactory;
if(pFactory == NULL)
return E_OUTOFMEMORY;
HRESULT result = pFactory->QueryInterface(iid, ppv);
return result;
}
else
return CLASS_E_CLASSNOTAVAILABLE;
}
extern "C" HRESULT _stdcall DllCanUnloadNow()
{
printf("enter CompB::DllCanUnloadNow\n");
if((g_ANumber == 0) && (g_LockNumber == 0))
return S_OK;
else
return S_FALSE;
}
extern "C" HRESULT _stdcall DllRegisterServer()
{
char szModule[1024];
DWORD dwResult = ::GetModuleFileName((HMODULE)g_hModule, szModule, 1024);
if(dwResult == 0)
return SELFREG_E_CLASS;
return RegisterServer(CLSID_ComponentB,
szModule,
"B.Object",
"B Component",
NULL);
}
extern "C" HRESULT _stdcall DllUnregisterServer()
{
return UnregisterServer(CLSID_ComponentB,
"B.Object",
NULL);
} | [
"haihai107@126.com"
] | haihai107@126.com |
76501bfd70b4a05eef6f7c732c8c931c2ccd3b2d | eed348530ed642edfa269ed24746d5e945d1fabc | /vescinterface.h | 4bfc7c95a82e59295d5c1315fb2a368b877a448e | [] | no_license | batitous/vesc_tool | f327747ebd4887e299a920ed38dc1f785fa55536 | cc35bcac90b82862fc90c696c3f83ca1e85343c2 | refs/heads/master | 2021-04-18T20:36:13.759195 | 2019-07-15T08:45:33 | 2019-07-15T08:45:33 | 126,341,354 | 0 | 1 | null | 2019-07-15T08:45:34 | 2018-03-22T13:42:55 | C++ | UTF-8 | C++ | false | false | 4,399 | h | /*
Copyright 2016 - 2017 Benjamin Vedder benjamin@vedder.se
This file is part of VESC Tool.
VESC Tool is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
VESC Tool is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef VESCINTERFACE_H
#define VESCINTERFACE_H
#include <QObject>
#include <QTimer>
#include <QByteArray>
#include <QList>
#include <QTcpSocket>
#ifdef HAS_SERIALPORT
#include <QSerialPort>
#endif
#include "datatypes.h"
#include "configparams.h"
#include "commands.h"
#include "packet.h"
#include "bleuart.h"
class VescInterface : public QObject
{
Q_OBJECT
public:
explicit VescInterface(QObject *parent = 0);
Q_INVOKABLE Commands *commands() const;
Q_INVOKABLE ConfigParams *mcConfig();
Q_INVOKABLE ConfigParams *appConfig();
Q_INVOKABLE ConfigParams *infoConfig();
Q_INVOKABLE QStringList getSupportedFirmwares();
QList<QPair<int, int> > getSupportedFirmwarePairs();
Q_INVOKABLE QString getFirmwareNow();
Q_INVOKABLE void emitStatusMessage(const QString &msg, bool isGood);
Q_INVOKABLE void emitMessageDialog(const QString &title, const QString &msg, bool isGood, bool richText = false);
Q_INVOKABLE bool fwRx();
Q_INVOKABLE BleUart* bleDevice();
// Connection
Q_INVOKABLE bool isPortConnected();
Q_INVOKABLE void disconnectPort();
Q_INVOKABLE bool reconnectLastPort();
Q_INVOKABLE bool autoconnect();
Q_INVOKABLE QString getConnectedPortName();
bool connectSerial(QString port, int baudrate = 115200);
QList<VSerialInfo_t> listSerialPorts();
Q_INVOKABLE void connectTcp(QString server, int port);
Q_INVOKABLE void connectBle(QString address);
Q_INVOKABLE bool isAutoconnectOngoing() const;
Q_INVOKABLE double getAutoconnectProgress() const;
signals:
void statusMessage(const QString &msg, bool isGood);
void messageDialog(const QString &title, const QString &msg, bool isGood, bool richText);
void fwUploadStatus(const QString &status, double progress, bool isOngoing);
void serialPortNotWritable(const QString &port);
void fwRxChanged(bool rx, bool limited);
void portConnectedChanged();
void autoConnectProgressUpdated(double progress, bool isOngoing);
void autoConnectFinished();
public slots:
private slots:
#ifdef HAS_SERIALPORT
void serialDataAvailable();
void serialPortError(QSerialPort::SerialPortError error);
#endif
void tcpInputConnected();
void tcpInputDisconnected();
void tcpInputDataAvailable();
void tcpInputError(QAbstractSocket::SocketError socketError);
void bleDataRx(QByteArray data);
void timerSlot();
void packetDataToSend(QByteArray &data);
void packetReceived(QByteArray &data);
void cmdDataToSend(QByteArray &data);
void fwVersionReceived(int major, int minor, QString hw, QByteArray uuid);
void appconfUpdated();
void mcconfUpdated();
void ackReceived(QString ackType);
private:
typedef enum {
CONN_NONE = 0,
CONN_SERIAL,
CONN_TCP,
CONN_BLE
} conn_t;
ConfigParams *mMcConfig;
ConfigParams *mAppConfig;
ConfigParams *mInfoConfig;
QTimer *mTimer;
Packet *mPacket;
Commands *mCommands;
bool mFwVersionReceived;
int mFwRetries;
int mFwPollCnt;
QString mFwTxt;
QString mHwTxt;
bool mIsUploadingFw;
// Connections
conn_t mLastConnType;
#ifdef HAS_SERIALPORT
QSerialPort *mSerialPort;
QString mLastSerialPort;
int mLastSerialBaud;
#endif
QTcpSocket *mTcpSocket;
bool mTcpConnected;
QString mLastTcpServer;
int mLastTcpPort;
BleUart *mBleUart;
QString mLastBleAddr;
bool mSendCanBefore = false;
int mCanIdBefore = 0;
bool mWasConnected;
bool mAutoconnectOngoing;
double mAutoconnectProgress;
void updateFwRx(bool fwRx);
};
#endif // VESCINTERFACE_H
| [
"benjamin@vedder.se"
] | benjamin@vedder.se |
772c42d6cd9e2aa8b52a2cebcdd95bdcfa16a7a4 | 208bfdca6a44e6a92f449152e51dc19defb1b495 | /include/circle_detection/tumult/tools/Vertex.h | 22b7edc4229c712184d39de2f059e161c1b7ed47 | [] | no_license | jonathan-schwarz/circle_detection_ros | 2c8404af722416e2b84b8551e4c523ccac09c9b4 | 356b3f44284a134e04d048e9a26d13aea6dc8c7c | refs/heads/master | 2020-05-30T16:37:16.573145 | 2013-09-02T13:55:37 | 2013-09-02T13:55:37 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,063 | h | #ifndef ___VERTEX__H
#define ___VERTEX__H
#include <math.h>
#include <iostream>
#include <assert.h>
#include <iomanip>
template<typename SCALAR_TYPE, size_t DIMENSION>
class Vertex
{
public:
Vertex();
Vertex(const SCALAR_TYPE& init );
Vertex(const Vertex<SCALAR_TYPE,DIMENSION>& other);
Vertex(SCALAR_TYPE data[DIMENSION]);
virtual ~Vertex();
SCALAR_TYPE get(size_t dimension) const;
SCALAR_TYPE norm()const;
SCALAR_TYPE distance(const Vertex<SCALAR_TYPE,DIMENSION>& other)const;
Vertex<SCALAR_TYPE,DIMENSION> operator+(const Vertex<SCALAR_TYPE,DIMENSION>& other)const;
Vertex<SCALAR_TYPE,DIMENSION> operator-(const Vertex<SCALAR_TYPE,DIMENSION>& other)const;
SCALAR_TYPE operator*(const Vertex<SCALAR_TYPE,DIMENSION>& other)const;
Vertex<SCALAR_TYPE,DIMENSION> operator*(const SCALAR_TYPE& scalar)const;
Vertex<SCALAR_TYPE,DIMENSION> operator/(const SCALAR_TYPE& scalar)const;
Vertex<SCALAR_TYPE,DIMENSION>& operator+=(const Vertex<SCALAR_TYPE,DIMENSION>& other);
Vertex<SCALAR_TYPE,DIMENSION>& operator-=(const Vertex<SCALAR_TYPE,DIMENSION>& other);
Vertex<SCALAR_TYPE,DIMENSION>& operator*=(const SCALAR_TYPE& scalar);
Vertex<SCALAR_TYPE,DIMENSION>& operator/=(const SCALAR_TYPE& scalar);
Vertex<SCALAR_TYPE,DIMENSION>& operator=(const Vertex<SCALAR_TYPE,DIMENSION>& other);
SCALAR_TYPE& operator[](size_t index);
const SCALAR_TYPE& operator[](size_t index)const;
size_t getDimension()const{ return DIMENSION; };
void print(std::ostream& out)const;
Vertex<SCALAR_TYPE,DIMENSION> reScale(const SCALAR_TYPE& newLength)const;
private:
SCALAR_TYPE m_data[DIMENSION];
protected:
SCALAR_TYPE* getData() { return m_data; };
};
template <typename SCALAR_TYPE, size_t DIMENSION>
Vertex<SCALAR_TYPE,DIMENSION>::Vertex()
{};
template <typename SCALAR_TYPE, size_t DIMENSION>
Vertex<SCALAR_TYPE,DIMENSION>::Vertex(const SCALAR_TYPE& init)
{
for(size_t i = 0; i < DIMENSION; i++ )
{
m_data[i] = init;
}
};
template <typename SCALAR_TYPE, size_t DIMENSION>
Vertex<SCALAR_TYPE,DIMENSION>::Vertex(const Vertex<SCALAR_TYPE,DIMENSION>& other)
{
for(size_t i = 0; i < DIMENSION; i++ )
{
m_data[i] = other.get(i);
}
};
template <typename SCALAR_TYPE, size_t DIMENSION>
Vertex<SCALAR_TYPE,DIMENSION>::Vertex(SCALAR_TYPE data[DIMENSION])
{
for(size_t i = 0; i < DIMENSION; i++ )
{
m_data[i] = data[i];
}
};
template <typename SCALAR_TYPE, size_t DIMENSION>
Vertex<SCALAR_TYPE,DIMENSION>::~Vertex()
{
// std::cout << "destroy Vertex:\t" << *this << "\tfinished\n";
};
template <typename SCALAR_TYPE, size_t DIMENSION>
SCALAR_TYPE Vertex<SCALAR_TYPE,DIMENSION>::get(size_t dimension) const
{
assert(dimension < DIMENSION);
return m_data[dimension];
};
template <typename SCALAR_TYPE, size_t DIMENSION>
SCALAR_TYPE& Vertex<SCALAR_TYPE,DIMENSION>::operator[](size_t index)
{
//assert(index>=0);
assert(index<DIMENSION);
return m_data[index];
};
template <typename SCALAR_TYPE, size_t DIMENSION>
const SCALAR_TYPE& Vertex<SCALAR_TYPE,DIMENSION>::operator[](size_t index)const
{
//assert(index>=0);
assert(index<DIMENSION);
return m_data[index];
};
template <typename SCALAR_TYPE, size_t DIMENSION>
SCALAR_TYPE Vertex<SCALAR_TYPE,DIMENSION>::norm()const
{
const Vertex<SCALAR_TYPE,DIMENSION>& me = *this;
return sqrt( me * me );
};
template <typename SCALAR_TYPE, size_t DIMENSION>
SCALAR_TYPE Vertex<SCALAR_TYPE,DIMENSION>::distance(const Vertex<SCALAR_TYPE,DIMENSION>& other)const
{
return Vertex<SCALAR_TYPE,DIMENSION>(*this-other).norm();
};
template <typename SCALAR_TYPE, size_t DIMENSION>
Vertex<SCALAR_TYPE,DIMENSION> Vertex<SCALAR_TYPE,DIMENSION>::operator+(const Vertex<SCALAR_TYPE,DIMENSION>& other)const
{
Vertex<SCALAR_TYPE,DIMENSION> temp(*this);
temp+=other;
return temp;
};
template <typename SCALAR_TYPE, size_t DIMENSION>
Vertex<SCALAR_TYPE,DIMENSION> Vertex<SCALAR_TYPE,DIMENSION>::operator-(const Vertex<SCALAR_TYPE,DIMENSION>& other)const
{
Vertex<SCALAR_TYPE,DIMENSION> temp(*this);
temp-=other;
return temp;
};
template <typename SCALAR_TYPE, size_t DIMENSION>
SCALAR_TYPE Vertex<SCALAR_TYPE,DIMENSION>::operator*(const Vertex<SCALAR_TYPE,DIMENSION>& other)const
{
SCALAR_TYPE swp(0);
for(size_t i = 0; i < DIMENSION; i++)
{
swp += get(i) * other.get(i);
}
return swp;
};
template <typename SCALAR_TYPE, size_t DIMENSION>
Vertex<SCALAR_TYPE,DIMENSION> Vertex<SCALAR_TYPE,DIMENSION>::operator*(const SCALAR_TYPE& scalar)const
{
Vertex<SCALAR_TYPE,DIMENSION> temp(*this);
temp*=scalar;
return temp;
};
template <typename SCALAR_TYPE, size_t DIMENSION>
Vertex<SCALAR_TYPE,DIMENSION> Vertex<SCALAR_TYPE,DIMENSION>::operator/(const SCALAR_TYPE& scalar)const
{
Vertex<SCALAR_TYPE,DIMENSION> temp(*this);
temp/=scalar;
return temp;
};
template <typename SCALAR_TYPE, size_t DIMENSION>
Vertex<SCALAR_TYPE,DIMENSION>& Vertex<SCALAR_TYPE,DIMENSION>::operator+=(const Vertex<SCALAR_TYPE,DIMENSION>& other)
{
for(size_t i = 0; i < DIMENSION; i++)
{
m_data[i] += other.get(i);
}
return *this;
};
template <typename SCALAR_TYPE, size_t DIMENSION>
Vertex<SCALAR_TYPE,DIMENSION>& Vertex<SCALAR_TYPE,DIMENSION>::operator-=(const Vertex<SCALAR_TYPE,DIMENSION>& other)
{
for(size_t i = 0; i < DIMENSION; i++)
{
m_data[i] -= other.get(i);
}
return *this;
};
template <typename SCALAR_TYPE, size_t DIMENSION>
Vertex<SCALAR_TYPE,DIMENSION>& Vertex<SCALAR_TYPE,DIMENSION>::operator*=(const SCALAR_TYPE& scalar)
{
for(size_t i = 0; i < DIMENSION; i++)
{
m_data[i] *= scalar;
}
return *this;
};
template <typename SCALAR_TYPE, size_t DIMENSION>
Vertex<SCALAR_TYPE,DIMENSION>& Vertex<SCALAR_TYPE,DIMENSION>::operator/=(const SCALAR_TYPE& scalar)
{
for(size_t i = 0; i < DIMENSION; i++)
{
m_data[i] /= scalar;
}
return *this;
};
template <typename SCALAR_TYPE, size_t DIMENSION>
Vertex<SCALAR_TYPE,DIMENSION>& Vertex<SCALAR_TYPE,DIMENSION>::operator=(const Vertex<SCALAR_TYPE,DIMENSION>& other)
{
if(&other != this)
{
for(size_t i = 0; i < DIMENSION; i++ )
{
m_data[i] = other.get(i);
}
}
return *this;
};
template <typename SCALAR_TYPE, size_t DIMENSION>
Vertex<SCALAR_TYPE,DIMENSION> Vertex<SCALAR_TYPE,DIMENSION>::reScale(const SCALAR_TYPE& newLength)const
{
Vertex<SCALAR_TYPE,DIMENSION> ret = *this/this->norm();
ret = ret*newLength;
return ret;
};
template <typename SCALAR_TYPE, size_t DIMENSION>
void Vertex<SCALAR_TYPE,DIMENSION>::print(std::ostream& out)const
{
for(size_t i = 0; i < DIMENSION; i++)
{
out << std::setw(8) << std::setprecision(4)<< this->get(i);
if( i < DIMENSION - 1 )
{
out << "\t";
}
}
};
//output...
template <typename SCALAR_TYPE, size_t DIMENSION>
std::ostream& operator<<(std::ostream& out, const Vertex<SCALAR_TYPE,DIMENSION>& vertex)
{
vertex.print(out);
return out;
};
#endif //___VERTEX__H
| [
"youbot@ubuntu.(none)"
] | youbot@ubuntu.(none) |
6396ad6f00873f6d1f55c60842f9095ae9b77fce | 8a28f36f268e5c9239f2ca5b5a324094b6a181dd | /Line.h | 68063aba07862d4d0afca92aeeaa8a6a9142757a | [] | no_license | Junix-honor/Board | fdffc2b01491238b40db99bc01e0dfe0144a4725 | c041bfb063e8fdedb9ba2906df0dca7e61d57b36 | refs/heads/master | 2023-01-28T17:07:45.943019 | 2020-12-07T15:16:56 | 2020-12-07T15:16:56 | 319,358,057 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 232 | h | #pragma once
#include "graph.h"
class Line :
public graph
{
public:
Line();
~Line();
Line(const Line& L);
void DrawGraph();
Line* renew();
bool IsInGraph(screenPt TP, double error);
bool IsEnd();
const char* getType();
};
| [
"957824346@qq,com"
] | 957824346@qq,com |
8ef33d0cfa01b9ec7f35dfac1393f2b57add8667 | 94db39b9620020f23ecc9a1b4a6cc6a5a55b23a7 | /Sort, search algorithms/Вариант б-7/inch_vector.cpp | 5c1cf932ef707a0eb57bab2124f80229ab92fac5 | [] | no_license | bmvskii/DataStructuresAndAlgorithms | 87926b75decc4f47ca0809bfae45f944e3e6b4f3 | 67b6842fe10156f48132435080ef18c445a851d4 | refs/heads/master | 2020-03-25T02:03:36.200164 | 2018-08-02T09:51:33 | 2018-08-02T09:51:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,007 | cpp | #include "inch_vector.hpp"
#include <cstring>
#include <iostream>
#include <cassert>
void InchVectorInit ( InchVector & _vector, int _allocatedSize )
{
_vector.m_pData = new EnglishLengthUnit[ _allocatedSize ];
_vector.m_nAllocated = _allocatedSize;
_vector.m_nUsed = 0;
}
void InchVectorDestroy ( InchVector & _vector )
{
delete[] _vector.m_pData;
}
void InchVectorClear ( InchVector & _vector )
{
_vector.m_nUsed = 0;
}
bool InchVectorIsEmpty ( const InchVector & _vector )
{
return _vector.m_nUsed == 0;
}
void InchVectorGrow ( InchVector & _vector )
{
int nAllocatedNew = _vector.m_nAllocated * 2;
EnglishLengthUnit * pNewData = new EnglishLengthUnit[ nAllocatedNew ];
memcpy( pNewData, _vector.m_pData, sizeof( EnglishLengthUnit ) * _vector.m_nAllocated );
delete[] _vector.m_pData;
_vector.m_pData = pNewData;
_vector.m_nAllocated = nAllocatedNew;
}
void InchVectorPushBack ( InchVector & _vector, EnglishLengthUnit _data )
{
if ( _vector.m_nUsed == _vector.m_nAllocated )
InchVectorGrow( _vector );
_vector.m_pData[ _vector.m_nUsed++ ] = _data;
}
void InchVectorPopBack ( InchVector & _vector )
{
assert( ! InchVectorIsEmpty( _vector ) );
-- _vector.m_nUsed;
}
void InchVectorInsertAt ( InchVector & _vector, int _position, EnglishLengthUnit _data )
{
assert( _position >= 0 && _position < _vector.m_nUsed );
int newUsed = _vector.m_nUsed + 1;
if ( newUsed > _vector.m_nAllocated )
InchVectorGrow( _vector );
for ( int i = _vector.m_nUsed; i > _position; i-- )
_vector.m_pData[ i ] = _vector.m_pData[ i - 1];
_vector.m_pData[ _position ] = _data;
_vector.m_nUsed = newUsed;
}
void InchVectorDeleteAt ( InchVector & _vector, int _position )
{
assert( _position >= 0 && _position < _vector.m_nUsed );
for ( int i = _position + 1; i < _vector.m_nUsed; i++ )
_vector.m_pData[ i - 1 ] = _vector.m_pData[ i ];
-- _vector.m_nUsed;
}
| [
"evg.rogovoy@gmail.com"
] | evg.rogovoy@gmail.com |
94d8196b46f17f70b2a31ada1deca539bf41ea3c | 5ae5abff00fdb3c46ac858c5990bdb6976b04f7a | /sensorAgua.ino | da3fe7041a53157e7a8283a88e4277d65cbe384d | [] | no_license | rianmartinez/11-M-memorial | 598512de6840014ba525f21e01a5ceca4832d658 | f5eb713187abd129ba9582ca0d8031b792073326 | refs/heads/master | 2023-07-01T16:27:44.561516 | 2021-08-03T16:49:55 | 2021-08-03T16:49:55 | 325,355,338 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 465 | ino | //FUNCION DE LECTURA DE VALORES DEL SENSOR AGUA
#define WATER_SENSOR 4 //Conectado al pin 4 del ESP32
void sensorAgua() {
pinMode(WATER_SENSOR, INPUT);
}
void loopsensorAgua(){
int agua;
agua = digitalRead(WATER_SENSOR);
if (agua==1){ //cuando sea 1 considero que no hay agua
Serial.println("No hay agua en la superficie del sensor");
}
else{ //si a es 0 hay agua
Serial.println("Hay agua en la superficie del sensor");
}
}
| [
"you@example.com"
] | you@example.com |
3e95d00777a6fbe904e4362f1a32f3b13cf97b2f | 878c373a23c8df91c3c2fe01de9ddea849e60c42 | /Engine/src/AnimatedTranslation.cpp | 822391d7da6b95c896c01f54b0409a2dd3e5f638 | [] | no_license | b-pereira/CG1617 | 1b8c22db69fd94dc7a8e870ff35a3dbd5bb5e722 | 0cda2acaa3ce87c86aa592757b5e7900e6c27b7b | refs/heads/master | 2022-10-12T11:32:53.828698 | 2022-08-27T21:05:39 | 2022-08-27T21:05:39 | 82,802,438 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,972 | cpp | /*
* AnimatedTranslation.cpp
*
* Created on: 20/04/2017
* Author: rsilva
*/
#include "AnimatedTranslation.h"
#include "GL/glut.h"
#include <iostream>
#include "Point3d.h"
#include "Catmull-Rom.h"
#include <cmath>
AnimatedTranslation::AnimatedTranslation() :
time ( 0 )
{
}
AnimatedTranslation::AnimatedTranslation ( float tim ) :
time ( tim ), points()
{
}
void AnimatedTranslation::addPointCoords ( float x, float y, float z )
{ Point3d pt ( x, y, z );
points.push_back ( pt );
}
const vector<Point3d> &AnimatedTranslation::getVector() const
{ return points;
}
const float AnimatedTranslation::getTime() const
{ return time;
}
void AnimatedTranslation::applyTransformation() const
{ /**
* t \in [0 .. 1]
* cada iteração do parametro t tem que estar entre 0 e 1.
* Existe um contador global do tempo, que conta o tempo em milissegundos desde o início da
* aplicação até ao momento. Temos que, existe um tempo em segundos, que será
* o tempo total da distância percorrida numa curva. Relativamente ao contador global, esse tempo é relativo.
* Se o tempo total da curva for 10 segundos, pretende-se percorrer segundo a segundo até perfazer esse tempo
* vontando ao início. Se passaram 20 segundos desde o início da aplicação, a curva deve ser percorrida duas vezes.
* Daí a necessidade de um contador circular, através do módulo entre tempo total da aplicação e tempo total da curva.
* Como se pretende o que t (tempo) esteja entre 0 e 1 é necessário dividir o tempo decorrido no contador circular, pelo
* tempo total da curva, obtendo assim o valor pretendido.
*/
float t = ( ( glutGet ( GLUT_ELAPSED_TIME ) ) % ( int ) ( time*1000 ) ) / ( time*1000 );
float pos[3];
renderCatmullRomCurve ( points );
getGlobalCatmullRomPoint ( t, pos, points );
glTranslatef ( pos[0], pos[1], pos[2] );
}
AnimatedTranslation::~AnimatedTranslation()
{
}
| [
"pereirabruno05@gmail.com"
] | pereirabruno05@gmail.com |
c5b86cbff7fafe694459b2082b254d31648c13b8 | 3f8b288711bb5adc2394171507f54c62dc60c601 | /atcoder/abc/145a.cpp | 302c1f3f2f35cf3045dede4caf15ba5b6da72511 | [] | no_license | pontsuyo/procon | 65df6356f0ea1cfb619898d9e8cc6e326c0586e7 | 804aaeb526946172a8f41e0619712f5989b6b613 | refs/heads/master | 2021-06-15T15:13:04.441761 | 2021-03-20T05:26:54 | 2021-03-20T05:26:54 | 175,234,672 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 511 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define MOD (int) (1e9+7)
#define INF (int) 2e9
#define LLINF (ll) 2e18
int main(){
int n;
string s;
cin >> n >> s;
if(s.substr(0, n/2) == s.substr(n/2, n)){
cout << "Yes" << endl;
} else{
cout << "No" << endl;
}
// printf("%d\n", N);
return 0;
} | [
"tsuyopon9221@gmail.com"
] | tsuyopon9221@gmail.com |
89ac4b6456b7fd4c07651fe56157a5ab0c71cc92 | 650d7465a173237d244cd58dfafb642ecab5a135 | /ejercicios_lista/ejercicios_lista/src/ascendente.cpp | 99bb8110ff5ce9b818e1705cca843bf00465d7f4 | [] | no_license | ECipolatti/AED | 77c4fcb308e4d6b921fdbc524b17737a1d4b533f | 2deda197550a32d96acd92890daad0f7fd10ea14 | refs/heads/master | 2021-04-25T06:18:29.064504 | 2017-12-11T17:08:18 | 2017-12-11T17:08:18 | 113,885,512 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,697 | cpp | // $Id$
/* COMIENZO DE DESCRIPCION
En ciertas aplicaciones interesa separar las corridas ascendentes
en una lista de n\'umeros $L=~(~a_1,~a_2,~...,~a_n~)$, donde
cada corrida ascendente es una sublista de n\'umeros consecutivos
$a_i$, $a_{i+1}$, ..., $a_{i+k}$, la cual termina cuando
$a_{i+k}>a_{i+k+1}$, y es ascendente en el sentido de que
$a_i \le a_{i+1} \le ... \le a_{i+k}$. Por ejemplo, si la
lista es L = (0,5,6,9,4,3,9,6,5,5,2,3,7), entonces hay 6
corridas ascendentes, a saber: (0,5,6,9), (4), (3,9), (6),
(5,5) y (2,3,7).
\emph{Consigna:}
usando las operaciones de la clase lista, escribir una funci\'on
{\tt int ascendente (list <int> \&L, list < list<int> > \&LL)}
en la cual, dada una lista de enteros {\tt L}, almacena
cada corrida ascendente como una sublista en la lista de
listas {\tt LL}, devolviendo adem\'as el n\'umero $z$ de
corridas ascendentes halladas. \emph{Restricciones:}
a) El tiempo de ejecuci\'on del algoritmo debe ser $O(n)$,
b) La lista de listas {\tt LL} inicialmente est\'a vac\'{\i}a,
c) No usar otras estructuras auxiliares.
[Tomado en Examen Final 29-JUL-2004].
keywords: lista
FIN DE DESCRIPCION */
/*
__USE_WIKI__
Escribir una funci\'on
#int ascendente1 (list <int> &L, list<list<int> > &LL)#
que, dada una lista #L#, genera una lista de listas #LL#
de tal forma de que cada sublista es ascendente.
[Tomado en el Parcial 1 20-ABR-2006].
Escribir una funci\'on
#int ascendente2 (list <int> &L, vector < list<int> > &VL)#
que, dada una lista #L#, genera un vector de listas #VL#
de tal forma de que cada sublista es ascendente.
*/
// -----------------------------------------------------------------
// GNU: g++ -w -c util.cpp
// g++ -w -c ascendente.cpp
// g++ -w -o ascendente.exe util.o ascendente.o
// INTEL: icc -w -c util.cpp
// icc -w -c ascendente.cpp
// icc -w -o ascendente.exe util.o ascendente.o
// -----------------------------------------------------------------
#include <cmath>
#include <list>
#include <iostream>
#include "./util.h"
using namespace std ;
//--------------------------------------------------------------------
double drand_a() {
return double (rand())/double(RAND_MAX);
}
int irand_a(int m) {
return int(double(m)*drand());
}
//--------------------------------------------------------------------
void printa (list<int> & L){
list<int> :: iterator p, z;
cout << endl ;
cout << "lista ; L = " ;
p = L.begin();
while (p != L.end()) {
cout << *p << " " ; p++;
}
cout << endl << "pausa ... " ; cin.get ();
}
//--------------------------------------------------------------------
void printa (list<list<int> > & LL){
list<list<int> > :: iterator q;
list<int> :: iterator p, z;
int n, h ;
n = LL.size () ;
q = LL.begin();
h = 0 ;
while (q != LL.end()) {
p = q -> begin(); // comienzo de la sublista
z = q -> end(); // fin de la sublista
cout << endl ;
cout << "sublista " << h << " ; LL_h = " ;
while (p != z) {cout << *p << " " ; p++;}
cout << endl ;
h++;
q++;
} // end while
cout << endl ;
cout << "siza (LL) ; n = " << n << endl ;
cout << endl << "pausa ... " ; cin.get ();
}
//--------------------------------------------------------------------
void printa (vector<list<int> > & VL){
list<int> :: iterator p, z;
int n ;
n = VL.size () ;
for (int k = 0 ; k < n ; k++) {
cout << "sublista c : " ;
p = VL [k].begin ();
z = VL [k].end ();
while (p != z) cout << *p++ << " " ;
cout << endl ;
} // end k
cout << endl ;
cout << "siza (LL) ; n = " << n << endl ;
cout << endl << "pausa ... " ; cin.get ();
}
//--------------------------------------------------------------------
void genera_a (list<int> &L, int n, int maxval){
list<int> :: iterator p;
int k;
cout << endl ;
cout << "llena aleatoriamente una lista L de enteros" << endl;
p = L.begin ();
for (int j=0 ; j<n ; j++) {
k = irand (maxval); // valor aleatorio en [0,maxval)
p = L.insert (p,k); // inserta en la lista
}
}
//--------------------------------------------------------------------
// Item 1: lista de listas
// __FUNC_START__
// . los iteradores "p,q" recorren los numeros de la lista "L"
// . el iterador "r" va pasando de sublista en sublista, donde
// cada sublista es una corrida ascendente de la lista "L";
// . la lista vacia A es solo para inicializar cada nueva sublista.
int ascendente1_a (list <int> &L, list < list<int> > &LL) {
list < list<int> > :: iterator r;
list <int> :: iterator p, q;
list <int> A;
p = L.begin ();
while (p != L.end ()) {
// inserta una nueva sublista vacia "A" en la lista de listas "L"
r = LL.insert (LL.end(),A);
// inserta el valor "*p" de la lista "L" en la nueva sublista
r->insert (r->end(), *p) ;
// mientras no sea fin de la lista "L" y se verifica la condicion
// de corrida ascendente, va copiando a la sublista actual
q = p ; q++;
while (q != L.end () && *p <= *q) {
r->insert (r->end(), *q) ;
p++;
q++;
} // end while
p = q ; // se posiciona al principio de la sgte corrida
} // end while
printa (LL) ;
return LL.size() ;
}
//--------------------------------------------------------------------
// Otra solucion
int ascendente1_b (list<int> &L, list<list<int> > &LL) {
list<int>::iterator p, q;
list<list<int> >::iterator ql ;
int x ;
LL.clear();
p = L.begin ();
while (p != L.end ()) {
ql = LL.insert(LL.end(),list<int>());
while (1) {
x = *p++;
ql->insert(ql->end(),x);
if (p==L.end() || *p<x) break;
} // end while
} // end while
return LL.size();
}
// __FUNC_END__
//--------------------------------------------------------------------
// Item 2: vector de listas
//
// el iterador "p" recorre la lista "L"
// el iterador "q" recorre cada corrida ascendente en "L"
// el contador "h" va contando las corridas ascendentes halladas
int ascendente2 (list <int> &L, vector < list<int> > &VL) {
list <int> :: iterator p, q;
int h = 0 ;
p = L.begin ();
while (p != L.end ()) {
// copia el elemento "p" de "L" como el primero de la sublista "h"
VL [h].insert (VL [h].end (), *p) ;
// mientras no sea fin de lista y se verifica la condicion de
// corrida ascendente, va copiando elementos a la sublista "h"
q = p ; q++;
while (q != L.end () && *p <= *q) {
VL [h].insert (VL [h].end (), *q) ;
p++;
q++;
} // end while
h++ ; // para pasar a la eventual siguiente corrida ascendente
p = q ; // se posiciona al principio de la sgte corrida
} // end while
return (h) ;
}
//--------------------------------------------------------------------
void check(list<int> &L) {
list<list<int> > LL;
int nca = ascendente1_b (L,LL);
list<list<int> >::iterator ql = LL.begin();
while (ql!=LL.end()) {
cout << "sublista ascendente: ";
list<int>::iterator p = ql->begin();
while (p!=ql->end()) {
cout << " " << *p;
p++;
}
ql++;
cout << endl;
}
}
//--------------------------------------------------------------------
int main() {
list <int> L ;
list <list<int> > LL ;
int a [] = {3,7,0,0,3,4,6,4,2,7,-1};
int opcion = 2 ;
int h, n ;
// Titulos
cout << endl;
cout << "encuentra todas las Corridas Ascendentes (CA) " << endl ;
cout << "en una lista de numeros L " << endl;
int kaso = 1 ;
switch (kaso) {
case 1:
// Item 1: lista de listas "LL"
L.clear ();
genera_a (L, 50, 99) ; // Genera una lista "L" de numeros
printa (L);
h = ascendente1_a (L,LL) ; // una solucion
check (L); // otra solucion
break;
case 2:
// Item 2: vector de listas "VL"
if (opcion == 1) {
L.clear ();
insertl (L, a, -1) ; // Construye una lista predefinida
printa (L);
n = L.size () ; // alocamos para el peor caso: si las
vector <list<int> > VL (n); // sublistas resultaran de longitud 1
h = ascendente2 (L,VL) ;
printa (VL) ;
VL.clear ();
} else {
int const kmax = 20 ;
for (int k = 0; k < kmax ; k++) {
L.clear ();
randl (L,10,5.0);
printa (L);
n = L.size () ;
vector <list<int> > VL (n) ;
h = ascendente2 (L,VL) ;
printa (VL) ;
VL.clear () ;
} // end k
} // end if
break;
default:
cout << endl;
cout << "no previsto " << endl ;
} ;
cout << endl;
return 0;
}
// -----------------------------------------------------------------
| [
"pelecipo@gmial.com"
] | pelecipo@gmial.com |
9ccc2aa8e1ba1c10bb87a886ca05495a4c469a13 | d62a85e7e7aa9cfad3baf5606463f46b6b66cd4c | /AnKi/Renderer/DownscaleBlur.cpp | 4e075c0d4abf4d38e330d8af27fd637ab4a7c7f8 | [
"BSD-3-Clause",
"BSD-2-Clause"
] | permissive | code2man/anki-3d-engine | afe71f65ec96d941498cbba30574e3ff30a47b7a | 174eaf7fd937eb93d0f6ff3a6389a574e04725cb | refs/heads/master | 2023-07-03T14:47:43.960368 | 2021-08-12T18:50:47 | 2021-08-12T18:50:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,199 | cpp | // Copyright (C) 2009-2021, Panagiotis Christopoulos Charitos and contributors.
// All rights reserved.
// Code licensed under the BSD License.
// http://www.anki3d.org/LICENSE
#include <AnKi/Renderer/DownscaleBlur.h>
#include <AnKi/Renderer/Renderer.h>
#include <AnKi/Renderer/TemporalAA.h>
namespace anki
{
DownscaleBlur::~DownscaleBlur()
{
m_fbDescrs.destroy(getAllocator());
}
Error DownscaleBlur::init(const ConfigSet& cfg)
{
Error err = initInternal(cfg);
if(err)
{
ANKI_R_LOGE("Failed to initialize downscale blur");
}
return err;
}
Error DownscaleBlur::initInternal(const ConfigSet&)
{
m_passCount = computeMaxMipmapCount2d(m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y(),
DOWNSCALE_BLUR_DOWN_TO)
- 1;
ANKI_R_LOGI("Initializing dowscale blur (passCount: %u)", m_passCount);
// Create the miped texture
TextureInitInfo texinit = m_r->create2DRenderTargetDescription(
m_r->getPostProcessResolution().x() / 2, m_r->getPostProcessResolution().y() / 2,
LIGHT_SHADING_COLOR_ATTACHMENT_PIXEL_FORMAT, "DownscaleBlur");
texinit.m_usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_COMPUTE;
if(m_useCompute)
{
texinit.m_usage |= TextureUsageBit::SAMPLED_COMPUTE | TextureUsageBit::IMAGE_COMPUTE_WRITE;
}
else
{
texinit.m_usage |= TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE;
}
texinit.m_mipmapCount = U8(m_passCount);
texinit.m_initialUsage = TextureUsageBit::SAMPLED_COMPUTE;
m_rtTex = m_r->createAndClearRenderTarget(texinit);
// FB descr
if(!m_useCompute)
{
m_fbDescrs.create(getAllocator(), m_passCount);
for(U32 pass = 0; pass < m_passCount; ++pass)
{
m_fbDescrs[pass].m_colorAttachmentCount = 1;
m_fbDescrs[pass].m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::DONT_CARE;
m_fbDescrs[pass].m_colorAttachments[0].m_surface.m_level = pass;
m_fbDescrs[pass].bake();
}
}
// Shader programs
const ShaderProgramResourceVariant* variant = nullptr;
if(m_useCompute)
{
ANKI_CHECK(getResourceManager().loadResource("Shaders/DownscaleBlurCompute.ankiprog", m_prog));
m_prog->getOrCreateVariant(variant);
m_workgroupSize[0] = variant->getWorkgroupSizes()[0];
m_workgroupSize[1] = variant->getWorkgroupSizes()[1];
ANKI_ASSERT(variant->getWorkgroupSizes()[2] == 1);
}
else
{
ANKI_CHECK(getResourceManager().loadResource("Shaders/DownscaleBlur.ankiprog", m_prog));
m_prog->getOrCreateVariant(variant);
}
m_grProg = variant->getProgram();
return Error::NONE;
}
void DownscaleBlur::importRenderTargets(RenderingContext& ctx)
{
RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
m_runCtx.m_rt = rgraph.importRenderTarget(m_rtTex, TextureUsageBit::SAMPLED_COMPUTE);
}
void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
{
RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
m_runCtx.m_crntPassIdx = 0;
// Create passes
static const Array<CString, 8> passNames = {"DownBlur #0", "Down/Blur #1", "Down/Blur #2", "Down/Blur #3",
"Down/Blur #4", "Down/Blur #5", "Down/Blur #6", "Down/Blur #7"};
if(m_useCompute)
{
for(U32 i = 0; i < m_passCount; ++i)
{
ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(passNames[i]);
pass.setWork(
[](RenderPassWorkContext& rgraphCtx) {
static_cast<DownscaleBlur*>(rgraphCtx.m_userData)->run(rgraphCtx);
},
this, 0);
if(i > 0)
{
TextureSubresourceInfo sampleSubresource;
TextureSubresourceInfo renderSubresource;
sampleSubresource.m_firstMipmap = i - 1;
renderSubresource.m_firstMipmap = i;
pass.newDependency({m_runCtx.m_rt, TextureUsageBit::IMAGE_COMPUTE_WRITE, renderSubresource});
pass.newDependency({m_runCtx.m_rt, TextureUsageBit::SAMPLED_COMPUTE, sampleSubresource});
}
else
{
TextureSubresourceInfo renderSubresource;
pass.newDependency({m_runCtx.m_rt, TextureUsageBit::IMAGE_COMPUTE_WRITE, renderSubresource});
pass.newDependency({m_r->getTemporalAA().getHdrRt(), TextureUsageBit::SAMPLED_COMPUTE});
}
}
}
else
{
for(U32 i = 0; i < m_passCount; ++i)
{
GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass(passNames[i]);
pass.setWork(
[](RenderPassWorkContext& rgraphCtx) {
static_cast<DownscaleBlur*>(rgraphCtx.m_userData)->run(rgraphCtx);
},
this, 0);
pass.setFramebufferInfo(m_fbDescrs[i], {m_runCtx.m_rt}, {});
if(i > 0)
{
TextureSubresourceInfo sampleSubresource;
TextureSubresourceInfo renderSubresource;
sampleSubresource.m_firstMipmap = i - 1;
renderSubresource.m_firstMipmap = i;
pass.newDependency({m_runCtx.m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE, renderSubresource});
pass.newDependency({m_runCtx.m_rt, TextureUsageBit::SAMPLED_FRAGMENT, sampleSubresource});
}
else
{
TextureSubresourceInfo renderSubresource;
pass.newDependency({m_runCtx.m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE, renderSubresource});
pass.newDependency({m_r->getTemporalAA().getHdrRt(), TextureUsageBit::SAMPLED_FRAGMENT});
}
}
}
}
void DownscaleBlur::run(RenderPassWorkContext& rgraphCtx)
{
CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
cmdb->bindShaderProgram(m_grProg);
const U32 passIdx = m_runCtx.m_crntPassIdx++;
const U32 vpWidth = m_rtTex->getWidth() >> passIdx;
const U32 vpHeight = m_rtTex->getHeight() >> passIdx;
cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp);
if(passIdx > 0)
{
TextureSubresourceInfo sampleSubresource;
sampleSubresource.m_firstMipmap = passIdx - 1;
rgraphCtx.bindTexture(0, 1, m_runCtx.m_rt, sampleSubresource);
}
else
{
rgraphCtx.bindColorTexture(0, 1, m_r->getTemporalAA().getHdrRt());
}
if(m_useCompute)
{
TextureSubresourceInfo sampleSubresource;
sampleSubresource.m_firstMipmap = passIdx;
rgraphCtx.bindImage(0, 2, m_runCtx.m_rt, sampleSubresource);
UVec4 fbSize(vpWidth, vpHeight, 0, 0);
cmdb->setPushConstants(&fbSize, sizeof(fbSize));
}
if(m_useCompute)
{
dispatchPPCompute(cmdb, m_workgroupSize[0], m_workgroupSize[1], vpWidth, vpHeight);
}
else
{
cmdb->setViewport(0, 0, vpWidth, vpHeight);
drawQuad(cmdb);
}
}
} // end namespace anki
| [
"godlike@ancient-ritual.com"
] | godlike@ancient-ritual.com |
83c2fe95a8f37a80161e993734604b7c5f9887cc | 0d4864ca111609a82e95f0cfe79d0816073c3244 | /include/blp/blpapi_name.h | 31f952a763037c8c19d0665bb2fd21280225be2a | [] | no_license | Ilya-Grigoryan/Cornerstone_FVM | 1c5772894474c07fab6219ede9219faf8c43760f | 4dc88655aae1b9b013505b480b67caa8a9f6ef94 | refs/heads/master | 2020-04-27T18:27:21.437077 | 2014-02-13T21:07:20 | 2014-02-13T21:07:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,431 | h | /* Copyright 2012. Bloomberg Finance L.P.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions: The above copyright notice and this
* permission notice shall be included in all copies or substantial portions of
* the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
* EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
* OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
// blpapi_name.h -*-C++-*-
#ifndef INCLUDED_BLPAPI_NAME
#define INCLUDED_BLPAPI_NAME
//@PURPOSE: Provide a representation of a string for efficient comparison.
//
//@CLASSES:
// blpapi::Name: Represents a string in a form for efficient string comparison
//
//@DESCRIPTION: This component implements a representation of a string which is
// efficient for string comparison.
#include <blpapi_types.h>
#include <blpapi_defs.h>
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
BLPAPI_EXPORT
blpapi_Name_t* blpapi_Name_create(
const char* nameString);
BLPAPI_EXPORT
void blpapi_Name_destroy(
blpapi_Name_t *name);
BLPAPI_EXPORT
blpapi_Name_t* blpapi_Name_duplicate(
const blpapi_Name_t *src);
BLPAPI_EXPORT
int blpapi_Name_equalsStr(
const blpapi_Name_t *name,
const char *string);
BLPAPI_EXPORT
const char* blpapi_Name_string(
const blpapi_Name_t *name);
BLPAPI_EXPORT
size_t blpapi_Name_length(
const blpapi_Name_t *name);
BLPAPI_EXPORT
blpapi_Name_t* blpapi_Name_findName(
const char* nameString);
#ifdef __cplusplus
}
#include <algorithm> // for swap
#include <iostream>
#include <cstring> // for strcmp
namespace BloombergLP {
namespace blpapi {
class Name {
// Name represents a string in a form which is efficient for
// comparison.
//
// Name objects are used to identify and access the classes which
// define the schema - SchemaTypeDefinition,
// SchemaElementDefinition, SchemaConstant,
// SchemaConstantList. They are also used to access the values in
// Element objects and Message objects.
//
// The Name class is an efficient substitute for a string when
// used as a key, providing constant time comparison and ordering
// operations. Two Name objects constructed from strings for which
// strcmp() would return 0 will always compare equally.
//
// The ordering of Name objects (as defined by the operator<
// defined for Name) is consistent during a particular instance of
// a single application. However, the ordering is not lexical and
// is not consistent with the ordering of the same Name objects in
// any other process.
//
// Where possible Name objects should be initialized once and then
// reused. Creating a Name object from a char const* involves a
// search in a container requiring multiple string comparison
// operations.
//
// Note: Each Name instance refers to an entry in a global static
// table. Name instances for identical strings will refer to the
// same data. There is no provision for removing entries from the
// static table so Name objects should only be used when the set
// of input strings is bounded.
//
// For example, creating a Name for every possible field name and
// type in a data model is reasonable (in fact, the API will do
// this whenever it receives schema information). However
// converting sequence numbers on incoming messages to strings and
// creating a Name from each one of those strings will cause the
// static table to grow in an unbounded manner.
blpapi_Name_t *d_impl_p;
public:
// CLASS METHODS
static Name findName(const char* nameString);
// If a Name already exists which matches the specified
// 'nameString' it is returned. Otherwise a Name which will
// compare equal to a Name created using the default
// constructor is returned. The behaviour is undefined if
// 'nameString' does not point to a nul-terminated string.
static bool hasName(const char* nameString);
// Returns true if a Name has been created which matches the
// specified 'nameString' otherwise returns false. The
// behaviour is undefined if 'nameString' does not point to a
// nul-terminated string.
Name();
// Construct an uninitialized Name. An uninitialized Name can
// be assigned to, destroyed or tested for equality. The
// behaviour for all other operations is undefined.
Name(blpapi_Name_t *handle);
Name(const Name& original);
// Copy constructor.
explicit Name(const char* nameString);
// Construct a Name from the specified 'nameString' as long as
// 'nameString' points to a valid nul terminated string. Any
// null-terminated string can be specified (including an empty
// string).
//
// Constructing a Name from a char const* is a relatively
// expensive operation. If a Name will be used repeatedly it
// is preferable to create it once and re-use the object.
~Name();
// Destructor.
// MANIPULATORS
Name& operator=(const Name& rhs);
// Assignment operator.
// ACCESSORS
const char *string() const;
// Returns a pointer to the Name as a C style, null-terminated
// string. The pointer returned will be valid at least until
// main() exits.
size_t length() const;
// Returns the length of the Names string representation
// (excluding a terminating null). Using name.length() is more
// efficient than using strlen(name.cstr()) but the result is
// the same.
blpapi_Name_t* impl() const;
};
inline
bool operator==(const Name& lhs, const Name& rhs);
// Return true if the specified 'lhs' and 'rhs' name objects have
// the same value, and false otherwise. Two 'Name' objects have
// the same value if and only if the strings supplied when they
// were created would return 0 when compared using strcmp().
inline
bool operator!=(const Name& lhs, const Name& rhs);
// Equivalent to !(lhs==rhs).
inline
bool operator==(const Name& lhs, const char* rhs);
// Return true if the specified 'lhs' and 'rhs' name objects have the
// same value, and false otherwise. Two 'Name' objects have the same value
// if and only if the strings supplied when they were created would return
// 0 when compared with strcmp().
inline
bool operator<(const Name& lhs, const Name& rhs);
// This operator defines a sort ordering amongst Name objects. The
// sort ordering is stable within the lifetime of a single process
// but is not lexical and is also not guaranteed to be consistent
// across different processes (including repeated runs of the same
// process).
#if 0
inline
std::ostream& operator<<(std::ostream& output,
const Name& address);
#endif
inline
Name::Name(blpapi_Name_t *handle)
: d_impl_p(handle)
{
}
inline
Name::Name()
: d_impl_p(0)
{
}
inline
Name::Name(const Name& original)
: d_impl_p(blpapi_Name_duplicate(original.d_impl_p))
{
}
inline
Name::Name(const char* nameString)
{
d_impl_p = blpapi_Name_create(nameString);
}
inline
Name::~Name()
{
if (d_impl_p) {
blpapi_Name_destroy(d_impl_p);
}
}
inline
Name& Name::operator=(const Name& rhs)
{
if (&rhs != this) {
Name tmp(rhs);
std::swap(tmp.d_impl_p, d_impl_p);
}
return *this;
}
inline
const char* Name::string() const
{
return blpapi_Name_string(d_impl_p);
}
inline
size_t Name::length() const
{
return blpapi_Name_length(d_impl_p);
}
inline
blpapi_Name_t* Name::impl() const
{
return d_impl_p;
}
inline
Name Name::findName(const char* nameString)
{
return Name(blpapi_Name_findName(nameString));
}
inline
bool Name::hasName(const char* nameString)
{
return blpapi_Name_findName(nameString) ? true : false;
}
inline
bool operator==(const Name& lhs, const Name& rhs)
{
return (lhs.impl() == rhs.impl());
}
inline
bool operator==(const Name& lhs, const char* rhs)
{
return blpapi_Name_equalsStr(lhs.impl(), rhs) != 0;
}
inline
bool operator!=(const Name& lhs, const Name& rhs)
{
return !(lhs == rhs);
}
inline
bool operator<(const Name& lhs, const Name& rhs)
{
return std::strcmp(lhs.string(), rhs.string()) < 0;
}
inline
std::ostream& operator<<(std::ostream& stream,
const Name& name)
{
stream << name.string();
return stream;
}
} // close namespace blpapi {
} // close namespace BloombergLP {
#endif // __cplusplus
#endif // #ifndef INCLUDED_BLPAPI_NAME
| [
"ilya281989@gmail.com"
] | ilya281989@gmail.com |
24105fe60f67a7ce403a9da337ebefe3654869aa | 8f6e4aaf22263ad0ae34b8dcaa833c948613f06b | /BattleTank 4.14/Source/BattleTank/Private/TankAimingComponent.cpp | 488ed0b0799b4751cd9988b0b99740c9816c30f4 | [] | no_license | Weythran/04_BattleTank | c4f79fb6b2f57b183d7b46377ea396021e4e7212 | 760782a38fa4f26202ec14f20b7c199ab088d68e | refs/heads/master | 2021-01-12T21:07:37.766073 | 2016-12-16T03:43:37 | 2016-12-16T03:43:37 | 68,674,486 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,890 | cpp | // Fill out your copyright notice in the Description page of Project Settings.
#include "BattleTank.h"
#include "TankBarrel.h"
#include "TankTurret.h"
#include "Projectile.h"
#include "TankAimingComponent.h"
void UTankAimingComponent::Initialise(UTankBarrel* BarrelToSet, UTankTurret* TurretToSet)
{
Barrel = BarrelToSet;
Turret = TurretToSet;
}
// Sets default values for this component's properties
UTankAimingComponent::UTankAimingComponent()
{
// Set this component to be initialized when the game starts, and to be ticked every frame. You can turn these features
// off to improve performance if you don't need them.
// bWantsBeginPlay = true;
PrimaryComponentTick.bCanEverTick = true;
// ...
}
void UTankAimingComponent::BeginPlay()
{
// So that first fire is after initial reload
LastFireTime = FPlatformTime::Seconds();
GetRoundsLeft();
}
void UTankAimingComponent::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction)
{
if (RoundsLeft <= 0)
{
// UE_LOG(LogTemp, Warning, TEXT("OutOfAmmo - GREY"))
FiringState = EFiringState::OutOfAmmo;
}
else if ((FPlatformTime::Seconds() - LastFireTime) < ReloadTimeInSeconds)
{
// UE_LOG(LogTemp, Warning, TEXT("Reloading - RED"))
FiringState = EFiringState::Reloading;
}
else if (IsBarrelMoving())
{
// UE_LOG(LogTemp, Warning, TEXT("Aiming - YELLOW"))
FiringState = EFiringState::Aiming;
}
else
{
// UE_LOG(LogTemp, Warning, TEXT("Locked - GREEN"))
FiringState = EFiringState::Locked;
}
}
EFiringState UTankAimingComponent::GetFiringState() const
{
return FiringState;
}
bool UTankAimingComponent::IsBarrelMoving()
{
if (!ensure(Barrel)) { return false; }
auto BarrelForward = Barrel->GetForwardVector();
auto ADString = AimDirection.ToString();
auto BFString = BarrelForward.ToString();
if (BarrelForward.Equals(AimDirection, 0.01))
{
// UE_LOG(LogTemp, Warning, TEXT("Vectors are equal: AimDirection %s; BarrelForward %s"), *ADString, *BFString)
}
return !BarrelForward.Equals(AimDirection, 0.01);
}
void UTankAimingComponent::AimAt(FVector HitLocation)
{
if (!ensure(Barrel)) { return; }
FVector OutLaunchVelocity;
FVector StartLocation = Barrel->GetSocketLocation(FName("Projectile"));
bool bHaveAimSolution = UGameplayStatics::SuggestProjectileVelocity(
this,
OutLaunchVelocity,
StartLocation,
HitLocation,
LaunchSpeed,
false,
0,
0,
ESuggestProjVelocityTraceOption::DoNotTrace
); // Calculate the OutLaunchVelocity
if (bHaveAimSolution)
{
AimDirection = OutLaunchVelocity.GetSafeNormal();
MoveBarrelTowards(AimDirection);
}
}
void UTankAimingComponent::MoveBarrelTowards(FVector AimDirection)
{
if (!ensure(Barrel && Turret)) { return; }
// Work out the difference between current barrel rotation and AimDirection
auto BarrelRotator = Barrel->GetForwardVector().Rotation();
auto AimAsRotator = AimDirection.Rotation();
auto DeltaRotator = AimAsRotator - BarrelRotator;
Barrel->Elevate(DeltaRotator.Pitch);
if (DeltaRotator.Yaw < 0)
{
if (FMath::Abs(DeltaRotator.Yaw) > 180) { DeltaRotator.Yaw = 360 + DeltaRotator.Yaw; }
}
else if (DeltaRotator.Yaw > 0)
{
if (FMath::Abs(DeltaRotator.Yaw) > 180) { DeltaRotator.Yaw = DeltaRotator.Yaw - 360; }
}
Turret->RotateTurret(DeltaRotator.Yaw);
}
void UTankAimingComponent::Fire()
{
if ((FiringState == EFiringState::Locked || FiringState == EFiringState::Aiming))
{
if (!ensure(Barrel)) { return; }
if (!ensure(ProjectileBlueprint)) { return; }
auto Projectile = GetWorld()->SpawnActor<AProjectile>(ProjectileBlueprint,
Barrel->GetSocketLocation(FName("Projectile")),
Barrel->GetSocketRotation(FName("Projectile"))
);
Projectile->LaunchProjectile(LaunchSpeed);
RoundsLeft--;
GetRoundsLeft();
LastFireTime = FPlatformTime::Seconds();
}
}
int32 UTankAimingComponent::GetRoundsLeft() const
{
return RoundsLeft;
} | [
"tenkovskiy@yahoo.com"
] | tenkovskiy@yahoo.com |
295f8ab42b245e55f8e8b22f9cec4ee19ef1bd70 | f021919ba3c6fe61e63bc74b1b57449ba10347c1 | /duilib/共享Demo/Duilib扩展交流，请先阅读ReadMeFirst/CommonLib/Duilib11x/UICommonControls.cpp | 9e42fe327787a13888d26837a45c5d4f7ad38601 | [
"MIT",
"Libpng",
"Zlib",
"Apache-2.0",
"BSD-2-Clause"
] | permissive | cnsuhao/ComBase | 67809cdd204287da5e7a734b319b4dafc6d266c2 | dc44aa7fb6dc9181261d88acada28d52fb18630f | refs/heads/master | 2021-06-20T01:40:54.290269 | 2017-07-23T11:05:40 | 2017-07-23T11:05:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 84,644 | cpp | #include "StdAfx.h"
namespace DuiLib {
/////////////////////////////////////////////////////////////////////////////////////
//
//
CLabelUI::CLabelUI() : m_uTextStyle(DT_VCENTER), m_dwTextColor(0),
m_dwDisabledTextColor(0), m_iFont(-1), m_bShowHtml(false)
{
::ZeroMemory(&m_rcTextPadding, sizeof(m_rcTextPadding));
}
LPCTSTR CLabelUI::GetClass() const
{
return _T("LabelUI");
}
LPVOID CLabelUI::GetInterface(LPCTSTR pstrName)
{
if( _tcscmp(pstrName, _T("Label")) == 0 ) return static_cast<CLabelUI*>(this);
return CControlUI::GetInterface(pstrName);
}
void CLabelUI::SetTextStyle(UINT uStyle)
{
m_uTextStyle = uStyle;
Invalidate();
}
UINT CLabelUI::GetTextStyle() const
{
return m_uTextStyle;
}
void CLabelUI::SetTextColor(DWORD dwTextColor)
{
m_dwTextColor = dwTextColor;
}
DWORD CLabelUI::GetTextColor() const
{
return m_dwTextColor;
}
void CLabelUI::SetDisabledTextColor(DWORD dwTextColor)
{
m_dwDisabledTextColor = dwTextColor;
}
DWORD CLabelUI::GetDisabledTextColor() const
{
return m_dwDisabledTextColor;
}
void CLabelUI::SetFont(int index)
{
m_iFont = index;
}
int CLabelUI::GetFont() const
{
return m_iFont;
}
RECT CLabelUI::GetTextPadding() const
{
return m_rcTextPadding;
}
void CLabelUI::SetTextPadding(RECT rc)
{
m_rcTextPadding = rc;
Invalidate();
}
bool CLabelUI::IsShowHtml()
{
return m_bShowHtml;
}
void CLabelUI::SetShowHtml(bool bShowHtml)
{
if( m_bShowHtml == bShowHtml ) return;
m_bShowHtml = bShowHtml;
Invalidate();
}
SIZE CLabelUI::EstimateSize(SIZE szAvailable)
{
if( m_cxyFixed.cy == 0 ) return CSize(m_cxyFixed.cx, m_pManager->GetFontInfo(GetFont())->tm.tmHeight + 4);
return CControlUI::EstimateSize(szAvailable);
}
void CLabelUI::DoEvent(TEventUI& event)
{
if( event.Type == UIEVENT_SETFOCUS )
{
m_bFocused = true;
return;
}
if( event.Type == UIEVENT_KILLFOCUS )
{
m_bFocused = false;
return;
}
if( event.Type == UIEVENT_MOUSEENTER )
{
return;
}
if( event.Type == UIEVENT_MOUSELEAVE )
{
return;
}
CControlUI::DoEvent(event);
}
void CLabelUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue)
{
if( _tcscmp(pstrName, _T("align")) == 0 ) {
if( _tcsstr(pstrValue, _T("left")) != NULL ) {
m_uTextStyle &= ~(DT_CENTER | DT_RIGHT | DT_TOP | DT_BOTTOM);
m_uTextStyle |= DT_LEFT;
}
if( _tcsstr(pstrValue, _T("center")) != NULL ) {
m_uTextStyle &= ~(DT_LEFT | DT_RIGHT | DT_TOP | DT_BOTTOM);
m_uTextStyle |= DT_CENTER;
}
if( _tcsstr(pstrValue, _T("right")) != NULL ) {
m_uTextStyle &= ~(DT_LEFT | DT_CENTER | DT_TOP | DT_BOTTOM);
m_uTextStyle |= DT_RIGHT;
}
if( _tcsstr(pstrValue, _T("top")) != NULL ) {
m_uTextStyle &= ~(DT_BOTTOM | DT_VCENTER | DT_LEFT | DT_RIGHT);
m_uTextStyle |= DT_TOP;
}
if( _tcsstr(pstrValue, _T("bottom")) != NULL ) {
m_uTextStyle &= ~(DT_TOP | DT_VCENTER | DT_LEFT | DT_RIGHT);
m_uTextStyle |= DT_BOTTOM;
}
}
else if( _tcscmp(pstrName, _T("endellipsis")) == 0 ) {
if( _tcscmp(pstrValue, _T("true")) == 0 ) m_uTextStyle |= DT_END_ELLIPSIS;
else m_uTextStyle &= ~DT_END_ELLIPSIS;
}
else if( _tcscmp(pstrName, _T("font")) == 0 ) SetFont(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("textcolor")) == 0 ) {
if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
LPTSTR pstr = NULL;
DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
SetTextColor(clrColor);
}
else if( _tcscmp(pstrName, _T("disabledtextcolor")) == 0 ) {
if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
LPTSTR pstr = NULL;
DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
SetDisabledTextColor(clrColor);
}
else if( _tcscmp(pstrName, _T("textpadding")) == 0 ) {
RECT rcTextPadding = { 0 };
LPTSTR pstr = NULL;
rcTextPadding.left = _tcstol(pstrValue, &pstr, 10); ASSERT(pstr);
rcTextPadding.top = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
rcTextPadding.right = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
rcTextPadding.bottom = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
SetTextPadding(rcTextPadding);
}
else if( _tcscmp(pstrName, _T("showhtml")) == 0 ) SetShowHtml(_tcscmp(pstrValue, _T("true")) == 0);
else CControlUI::SetAttribute(pstrName, pstrValue);
}
void CLabelUI::PaintText(HDC hDC)
{
if( m_dwTextColor == 0 ) m_dwTextColor = m_pManager->GetDefaultFontColor();
if( m_dwDisabledTextColor == 0 ) m_dwDisabledTextColor = m_pManager->GetDefaultDisabledColor();
if( m_sText.IsEmpty() ) return;
int nLinks = 0;
RECT rc = m_rcItem;
rc.left += m_rcTextPadding.left;
rc.right -= m_rcTextPadding.right;
rc.top += m_rcTextPadding.top;
rc.bottom -= m_rcTextPadding.bottom;
if( IsEnabled() ) {
if( m_bShowHtml )
CRenderEngine::DrawHtmlText(hDC, m_pManager, rc, m_sText, m_dwTextColor, \
NULL, NULL, nLinks, DT_SINGLELINE | m_uTextStyle);
else
CRenderEngine::DrawText(hDC, m_pManager, rc, m_sText, m_dwTextColor, \
m_iFont, DT_SINGLELINE | m_uTextStyle);
}
else {
if( m_bShowHtml )
CRenderEngine::DrawHtmlText(hDC, m_pManager, rc, m_sText, m_dwDisabledTextColor, \
NULL, NULL, nLinks, DT_SINGLELINE | m_uTextStyle);
else
CRenderEngine::DrawText(hDC, m_pManager, rc, m_sText, m_dwDisabledTextColor, \
m_iFont, DT_SINGLELINE | m_uTextStyle);
}
}
/////////////////////////////////////////////////////////////////////////////////////
//
//
CButtonUI::CButtonUI() : m_uButtonState(0), m_dwHotTextColor(0), m_dwPushedTextColor(0), m_dwFocusedTextColor(0)
{
m_uTextStyle = DT_SINGLELINE | DT_VCENTER | DT_CENTER;
}
LPCTSTR CButtonUI::GetClass() const
{
return _T("ButtonUI");
}
LPVOID CButtonUI::GetInterface(LPCTSTR pstrName)
{
if( _tcscmp(pstrName, _T("Button")) == 0 ) return static_cast<CButtonUI*>(this);
return CLabelUI::GetInterface(pstrName);
}
UINT CButtonUI::GetControlFlags() const
{
return (IsKeyboardEnabled() ? UIFLAG_TABSTOP : 0) | (IsEnabled() ? UIFLAG_SETCURSOR : 0);
}
void CButtonUI::DoEvent(TEventUI& event)
{
if( !IsMouseEnabled() && event.Type > UIEVENT__MOUSEBEGIN && event.Type < UIEVENT__MOUSEEND ) {
if( m_pParent != NULL ) m_pParent->DoEvent(event);
else CLabelUI::DoEvent(event);
return;
}
if( event.Type == UIEVENT_SETFOCUS )
{
Invalidate();
}
if( event.Type == UIEVENT_KILLFOCUS )
{
Invalidate();
}
if( event.Type == UIEVENT_KEYDOWN )
{
if (IsKeyboardEnabled()) {
if( event.chKey == VK_SPACE || event.chKey == VK_RETURN ) {
Activate();
return;
}
}
}
if( event.Type == UIEVENT_BUTTONDOWN || event.Type == UIEVENT_DBLCLICK )
{
if( ::PtInRect(&m_rcItem, event.ptMouse) && IsEnabled() ) {
m_uButtonState |= UISTATE_PUSHED | UISTATE_CAPTURED;
Invalidate();
}
return;
}
if( event.Type == UIEVENT_MOUSEMOVE )
{
if( (m_uButtonState & UISTATE_CAPTURED) != 0 ) {
if( ::PtInRect(&m_rcItem, event.ptMouse) ) m_uButtonState |= UISTATE_PUSHED;
else m_uButtonState &= ~UISTATE_PUSHED;
Invalidate();
}
return;
}
if( event.Type == UIEVENT_BUTTONUP )
{
if( (m_uButtonState & UISTATE_CAPTURED) != 0 ) {
if( ::PtInRect(&m_rcItem, event.ptMouse) ) Activate();
m_uButtonState &= ~(UISTATE_PUSHED | UISTATE_CAPTURED);
Invalidate();
}
return;
}
if( event.Type == UIEVENT_CONTEXTMENU )
{
if( IsContextMenuUsed() ) {
m_pManager->SendNotify(this, _T("menu"), event.wParam, event.lParam);
}
return;
}
if( event.Type == UIEVENT_MOUSEENTER )
{
if( IsEnabled() ) {
m_uButtonState |= UISTATE_HOT;
Invalidate();
}
return;
}
if( event.Type == UIEVENT_MOUSELEAVE )
{
if( IsEnabled() ) {
m_uButtonState &= ~UISTATE_HOT;
Invalidate();
}
return;
}
if( event.Type == UIEVENT_SETCURSOR ) {
::SetCursor(::LoadCursor(NULL, MAKEINTRESOURCE(IDC_HAND)));
return;
}
CLabelUI::DoEvent(event);
}
bool CButtonUI::Activate()
{
if( !CControlUI::Activate() ) return false;
if( m_pManager != NULL ) m_pManager->SendNotify(this, _T("click"));
return true;
}
void CButtonUI::SetEnabled(bool bEnable)
{
CControlUI::SetEnabled(bEnable);
if( !IsEnabled() ) {
m_uButtonState = 0;
}
}
void CButtonUI::SetHotTextColor(DWORD dwColor)
{
m_dwHotTextColor = dwColor;
}
DWORD CButtonUI::GetHotTextColor() const
{
return m_dwHotTextColor;
}
void CButtonUI::SetPushedTextColor(DWORD dwColor)
{
m_dwPushedTextColor = dwColor;
}
DWORD CButtonUI::GetPushedTextColor() const
{
return m_dwPushedTextColor;
}
void CButtonUI::SetFocusedTextColor(DWORD dwColor)
{
m_dwFocusedTextColor = dwColor;
}
DWORD CButtonUI::GetFocusedTextColor() const
{
return m_dwFocusedTextColor;
}
LPCTSTR CButtonUI::GetNormalImage()
{
return m_sNormalImage;
}
void CButtonUI::SetNormalImage(LPCTSTR pStrImage)
{
m_sNormalImage = pStrImage;
Invalidate();
}
LPCTSTR CButtonUI::GetHotImage()
{
return m_sHotImage;
}
void CButtonUI::SetHotImage(LPCTSTR pStrImage)
{
m_sHotImage = pStrImage;
Invalidate();
}
LPCTSTR CButtonUI::GetPushedImage()
{
return m_sPushedImage;
}
void CButtonUI::SetPushedImage(LPCTSTR pStrImage)
{
m_sPushedImage = pStrImage;
Invalidate();
}
LPCTSTR CButtonUI::GetFocusedImage()
{
return m_sFocusedImage;
}
void CButtonUI::SetFocusedImage(LPCTSTR pStrImage)
{
m_sFocusedImage = pStrImage;
Invalidate();
}
LPCTSTR CButtonUI::GetDisabledImage()
{
return m_sDisabledImage;
}
void CButtonUI::SetDisabledImage(LPCTSTR pStrImage)
{
m_sDisabledImage = pStrImage;
Invalidate();
}
SIZE CButtonUI::EstimateSize(SIZE szAvailable)
{
if( m_cxyFixed.cy == 0 ) return CSize(m_cxyFixed.cx, m_pManager->GetFontInfo(GetFont())->tm.tmHeight + 8);
return CControlUI::EstimateSize(szAvailable);
}
void CButtonUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue)
{
if( _tcscmp(pstrName, _T("normalimage")) == 0 ) SetNormalImage(pstrValue);
else if( _tcscmp(pstrName, _T("hotimage")) == 0 ) SetHotImage(pstrValue);
else if( _tcscmp(pstrName, _T("pushedimage")) == 0 ) SetPushedImage(pstrValue);
else if( _tcscmp(pstrName, _T("focusedimage")) == 0 ) SetFocusedImage(pstrValue);
else if( _tcscmp(pstrName, _T("disabledimage")) == 0 ) SetDisabledImage(pstrValue);
else if( _tcscmp(pstrName, _T("hottextcolor")) == 0 ) {
if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
LPTSTR pstr = NULL;
DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
SetHotTextColor(clrColor);
}
else if( _tcscmp(pstrName, _T("pushedtextcolor")) == 0 ) {
if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
LPTSTR pstr = NULL;
DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
SetPushedTextColor(clrColor);
}
else if( _tcscmp(pstrName, _T("focusedtextcolor")) == 0 ) {
if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
LPTSTR pstr = NULL;
DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
SetFocusedTextColor(clrColor);
}
else CLabelUI::SetAttribute(pstrName, pstrValue);
}
void CButtonUI::PaintText(HDC hDC)
{
if( IsFocused() ) m_uButtonState |= UISTATE_FOCUSED;
else m_uButtonState &= ~ UISTATE_FOCUSED;
if( !IsEnabled() ) m_uButtonState |= UISTATE_DISABLED;
else m_uButtonState &= ~ UISTATE_DISABLED;
if( m_dwTextColor == 0 ) m_dwTextColor = m_pManager->GetDefaultFontColor();
if( m_dwDisabledTextColor == 0 ) m_dwDisabledTextColor = m_pManager->GetDefaultDisabledColor();
if( m_sText.IsEmpty() ) return;
int nLinks = 0;
RECT rc = m_rcItem;
rc.left += m_rcTextPadding.left;
rc.right -= m_rcTextPadding.right;
rc.top += m_rcTextPadding.top;
rc.bottom -= m_rcTextPadding.bottom;
DWORD clrColor = IsEnabled()?m_dwTextColor:m_dwDisabledTextColor;
if( ((m_uButtonState & UISTATE_PUSHED) != 0) && (GetPushedTextColor() != 0) )
clrColor = GetPushedTextColor();
else if( ((m_uButtonState & UISTATE_HOT) != 0) && (GetHotTextColor() != 0) )
clrColor = GetHotTextColor();
else if( ((m_uButtonState & UISTATE_FOCUSED) != 0) && (GetFocusedTextColor() != 0) )
clrColor = GetFocusedTextColor();
if( m_bShowHtml )
CRenderEngine::DrawHtmlText(hDC, m_pManager, rc, m_sText, clrColor, \
NULL, NULL, nLinks, m_uTextStyle);
else
CRenderEngine::DrawText(hDC, m_pManager, rc, m_sText, clrColor, \
m_iFont, m_uTextStyle);
}
void CButtonUI::PaintStatusImage(HDC hDC)
{
if( IsFocused() ) m_uButtonState |= UISTATE_FOCUSED;
else m_uButtonState &= ~ UISTATE_FOCUSED;
if( !IsEnabled() ) m_uButtonState |= UISTATE_DISABLED;
else m_uButtonState &= ~ UISTATE_DISABLED;
if( (m_uButtonState & UISTATE_DISABLED) != 0 ) {
if( !m_sDisabledImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sDisabledImage) ) m_sDisabledImage.Empty();
else return;
}
}
else if( (m_uButtonState & UISTATE_PUSHED) != 0 ) {
if( !m_sPushedImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sPushedImage) ) m_sPushedImage.Empty();
else return;
}
}
else if( (m_uButtonState & UISTATE_HOT) != 0 ) {
if( !m_sHotImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sHotImage) ) m_sHotImage.Empty();
else return;
}
}
else if( (m_uButtonState & UISTATE_FOCUSED) != 0 ) {
if( !m_sFocusedImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sFocusedImage) ) m_sFocusedImage.Empty();
else return;
}
}
if( !m_sNormalImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sNormalImage) ) m_sNormalImage.Empty();
else return;
}
}
/////////////////////////////////////////////////////////////////////////////////////
//
//
COptionUI::COptionUI() : m_bSelected(false), m_dwSelectedTextColor(0)
{
}
COptionUI::~COptionUI()
{
if( !m_sGroupName.IsEmpty() && m_pManager ) m_pManager->RemoveOptionGroup(m_sGroupName, this);
}
LPCTSTR COptionUI::GetClass() const
{
return _T("OptionUI");
}
LPVOID COptionUI::GetInterface(LPCTSTR pstrName)
{
if( _tcscmp(pstrName, _T("Option")) == 0 ) return static_cast<COptionUI*>(this);
return CButtonUI::GetInterface(pstrName);
}
void COptionUI::SetManager(CPaintManagerUI* pManager, CControlUI* pParent, bool bInit)
{
CControlUI::SetManager(pManager, pParent, bInit);
if( bInit && !m_sGroupName.IsEmpty() ) {
if (m_pManager) m_pManager->AddOptionGroup(m_sGroupName, this);
}
}
LPCTSTR COptionUI::GetGroup() const
{
return m_sGroupName;
}
void COptionUI::SetGroup(LPCTSTR pStrGroupName)
{
if( pStrGroupName == NULL ) {
if( m_sGroupName.IsEmpty() ) return;
m_sGroupName.Empty();
}
else {
if( m_sGroupName == pStrGroupName ) return;
if (!m_sGroupName.IsEmpty() && m_pManager) m_pManager->RemoveOptionGroup(m_sGroupName, this);
m_sGroupName = pStrGroupName;
}
if( !m_sGroupName.IsEmpty() ) {
if (m_pManager) m_pManager->AddOptionGroup(m_sGroupName, this);
}
else {
if (m_pManager) m_pManager->RemoveOptionGroup(m_sGroupName, this);
}
Selected(m_bSelected);
}
bool COptionUI::IsSelected() const
{
return m_bSelected;
}
void COptionUI::Selected(bool bSelected)
{
if( m_bSelected == bSelected ) return;
m_bSelected = bSelected;
if( m_bSelected ) m_uButtonState |= UISTATE_SELECTED;
else m_uButtonState &= ~UISTATE_SELECTED;
if( m_pManager != NULL ) {
if( !m_sGroupName.IsEmpty() ) {
if( m_bSelected ) {
CStdPtrArray* aOptionGroup = m_pManager->GetOptionGroup(m_sGroupName);
for( int i = 0; i < aOptionGroup->GetSize(); i++ ) {
COptionUI* pControl = static_cast<COptionUI*>(aOptionGroup->GetAt(i));
if( pControl != this ) {
pControl->Selected(false);
}
}
m_pManager->SendNotify(this, _T("selectchanged"));
}
}
else {
m_pManager->SendNotify(this, _T("selectchanged"));
}
}
Invalidate();
}
bool COptionUI::Activate()
{
if( !CButtonUI::Activate() ) return false;
if( !m_sGroupName.IsEmpty() ) Selected(true);
else Selected(!m_bSelected);
return true;
}
void COptionUI::SetEnabled(bool bEnable)
{
CControlUI::SetEnabled(bEnable);
if( !IsEnabled() ) {
if( m_bSelected ) m_uButtonState = UISTATE_SELECTED;
else m_uButtonState = 0;
}
}
LPCTSTR COptionUI::GetSelectedImage()
{
return m_sSelectedImage;
}
void COptionUI::SetSelectedImage(LPCTSTR pStrImage)
{
m_sSelectedImage = pStrImage;
Invalidate();
}
void COptionUI::SetSelectedTextColor(DWORD dwTextColor)
{
m_dwSelectedTextColor = dwTextColor;
}
DWORD COptionUI::GetSelectedTextColor()
{
if (m_dwSelectedTextColor == 0) m_dwSelectedTextColor = m_pManager->GetDefaultFontColor();
return m_dwSelectedTextColor;
}
LPCTSTR COptionUI::GetForeImage()
{
return m_sForeImage;
}
void COptionUI::SetForeImage(LPCTSTR pStrImage)
{
m_sForeImage = pStrImage;
Invalidate();
}
SIZE COptionUI::EstimateSize(SIZE szAvailable)
{
if( m_cxyFixed.cy == 0 ) return CSize(m_cxyFixed.cx, m_pManager->GetFontInfo(GetFont())->tm.tmHeight + 8);
return CControlUI::EstimateSize(szAvailable);
}
void COptionUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue)
{
if( _tcscmp(pstrName, _T("group")) == 0 ) SetGroup(pstrValue);
else if( _tcscmp(pstrName, _T("selected")) == 0 ) Selected(_tcscmp(pstrValue, _T("true")) == 0);
else if( _tcscmp(pstrName, _T("selectedimage")) == 0 ) SetSelectedImage(pstrValue);
else if( _tcscmp(pstrName, _T("foreimage")) == 0 ) SetForeImage(pstrValue);
else if( _tcscmp(pstrName, _T("selectedtextcolor")) == 0 ) {
if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
LPTSTR pstr = NULL;
DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
SetSelectedTextColor(clrColor);
}
else CButtonUI::SetAttribute(pstrName, pstrValue);
}
void COptionUI::PaintStatusImage(HDC hDC)
{
m_uButtonState &= ~UISTATE_PUSHED;
if( (m_uButtonState & UISTATE_SELECTED) != 0 ) {
if( !m_sSelectedImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sSelectedImage) ) m_sSelectedImage.Empty();
else goto Label_ForeImage;
}
}
CButtonUI::PaintStatusImage(hDC);
Label_ForeImage:
if( !m_sForeImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sForeImage) ) m_sForeImage.Empty();
}
}
void COptionUI::PaintText(HDC hDC)
{
if( (m_uButtonState & UISTATE_SELECTED) != 0 )
{
DWORD oldTextColor = m_dwTextColor;
if( m_dwSelectedTextColor != 0 ) m_dwTextColor = m_dwSelectedTextColor;
if( m_dwTextColor == 0 ) m_dwTextColor = m_pManager->GetDefaultFontColor();
if( m_dwDisabledTextColor == 0 ) m_dwDisabledTextColor = m_pManager->GetDefaultDisabledColor();
if( m_sText.IsEmpty() ) return;
int nLinks = 0;
RECT rc = m_rcItem;
rc.left += m_rcTextPadding.left;
rc.right -= m_rcTextPadding.right;
rc.top += m_rcTextPadding.top;
rc.bottom -= m_rcTextPadding.bottom;
if( m_bShowHtml )
CRenderEngine::DrawHtmlText(hDC, m_pManager, rc, m_sText, IsEnabled()?m_dwTextColor:m_dwDisabledTextColor, \
NULL, NULL, nLinks, m_uTextStyle);
else
CRenderEngine::DrawText(hDC, m_pManager, rc, m_sText, IsEnabled()?m_dwTextColor:m_dwDisabledTextColor, \
m_iFont, m_uTextStyle);
m_dwTextColor = oldTextColor;
}
else
CButtonUI::PaintText(hDC);
}
/////////////////////////////////////////////////////////////////////////////////////
//
//
CTextUI::CTextUI() : m_nLinks(0), m_nHoverLink(-1)
{
m_uTextStyle = DT_WORDBREAK;
m_rcTextPadding.left = 2;
m_rcTextPadding.right = 2;
::ZeroMemory(m_rcLinks, sizeof(m_rcLinks));
}
CTextUI::~CTextUI()
{
}
LPCTSTR CTextUI::GetClass() const
{
return _T("TextUI");
}
LPVOID CTextUI::GetInterface(LPCTSTR pstrName)
{
if( _tcscmp(pstrName, _T("Text")) == 0 ) return static_cast<CTextUI*>(this);
return CLabelUI::GetInterface(pstrName);
}
UINT CTextUI::GetControlFlags() const
{
if( IsEnabled() && m_nLinks > 0 ) return UIFLAG_SETCURSOR;
else return 0;
}
CStdString* CTextUI::GetLinkContent(int iIndex)
{
if( iIndex >= 0 && iIndex < m_nLinks ) return &m_sLinks[iIndex];
return NULL;
}
void CTextUI::DoEvent(TEventUI& event)
{
if( !IsMouseEnabled() && event.Type > UIEVENT__MOUSEBEGIN && event.Type < UIEVENT__MOUSEEND ) {
if( m_pParent != NULL ) m_pParent->DoEvent(event);
else CLabelUI::DoEvent(event);
return;
}
if( event.Type == UIEVENT_SETCURSOR ) {
for( int i = 0; i < m_nLinks; i++ ) {
if( ::PtInRect(&m_rcLinks[i], event.ptMouse) ) {
::SetCursor(::LoadCursor(NULL, MAKEINTRESOURCE(IDC_HAND)));
return;
}
}
}
if( event.Type == UIEVENT_BUTTONDOWN || event.Type == UIEVENT_DBLCLICK && IsEnabled() ) {
for( int i = 0; i < m_nLinks; i++ ) {
if( ::PtInRect(&m_rcLinks[i], event.ptMouse) ) {
Invalidate();
return;
}
}
}
if( event.Type == UIEVENT_BUTTONUP && IsEnabled() ) {
for( int i = 0; i < m_nLinks; i++ ) {
if( ::PtInRect(&m_rcLinks[i], event.ptMouse) ) {
m_pManager->SendNotify(this, _T("link"), i);
return;
}
}
}
if( event.Type == UIEVENT_CONTEXTMENU )
{
return;
}
// When you move over a link
if( m_nLinks > 0 && event.Type == UIEVENT_MOUSEMOVE && IsEnabled() ) {
int nHoverLink = -1;
for( int i = 0; i < m_nLinks; i++ ) {
if( ::PtInRect(&m_rcLinks[i], event.ptMouse) ) {
nHoverLink = i;
break;
}
}
if(m_nHoverLink != nHoverLink) {
m_nHoverLink = nHoverLink;
Invalidate();
return;
}
}
if( event.Type == UIEVENT_MOUSELEAVE ) {
if( m_nLinks > 0 && IsEnabled() ) {
if(m_nHoverLink != -1) {
m_nHoverLink = -1;
Invalidate();
return;
}
}
}
CLabelUI::DoEvent(event);
}
SIZE CTextUI::EstimateSize(SIZE szAvailable)
{
RECT rcText = { 0, 0, MAX(szAvailable.cx, m_cxyFixed.cx), 9999 };
rcText.left += m_rcTextPadding.left;
rcText.right -= m_rcTextPadding.right;
if( m_bShowHtml ) {
int nLinks = 0;
CRenderEngine::DrawHtmlText(m_pManager->GetPaintDC(), m_pManager, rcText, m_sText, m_dwTextColor, NULL, NULL, nLinks, DT_CALCRECT | m_uTextStyle);
}
else {
CRenderEngine::DrawText(m_pManager->GetPaintDC(), m_pManager, rcText, m_sText, m_dwTextColor, m_iFont, DT_CALCRECT | m_uTextStyle);
}
SIZE cXY = {rcText.right - rcText.left + m_rcTextPadding.left + m_rcTextPadding.right,
rcText.bottom - rcText.top + m_rcTextPadding.top + m_rcTextPadding.bottom};
if( m_cxyFixed.cy != 0 ) cXY.cy = m_cxyFixed.cy;
return cXY;
}
void CTextUI::PaintText(HDC hDC)
{
if( m_sText.IsEmpty() ) {
m_nLinks = 0;
return;
}
if( m_dwTextColor == 0 ) m_dwTextColor = m_pManager->GetDefaultFontColor();
if( m_dwDisabledTextColor == 0 ) m_dwDisabledTextColor = m_pManager->GetDefaultDisabledColor();
if( m_sText.IsEmpty() ) return;
m_nLinks = lengthof(m_rcLinks);
RECT rc = m_rcItem;
rc.left += m_rcTextPadding.left;
rc.right -= m_rcTextPadding.right;
rc.top += m_rcTextPadding.top;
rc.bottom -= m_rcTextPadding.bottom;
if( IsEnabled() ) {
if( m_bShowHtml )
CRenderEngine::DrawHtmlText(hDC, m_pManager, rc, m_sText, m_dwTextColor, \
m_rcLinks, m_sLinks, m_nLinks, m_uTextStyle);
else
CRenderEngine::DrawText(hDC, m_pManager, rc, m_sText, m_dwTextColor, \
m_iFont, m_uTextStyle);
}
else {
if( m_bShowHtml )
CRenderEngine::DrawHtmlText(hDC, m_pManager, rc, m_sText, m_dwDisabledTextColor, \
m_rcLinks, m_sLinks, m_nLinks, m_uTextStyle);
else
CRenderEngine::DrawText(hDC, m_pManager, rc, m_sText, m_dwDisabledTextColor, \
m_iFont, m_uTextStyle);
}
}
/////////////////////////////////////////////////////////////////////////////////////
//
//
CProgressUI::CProgressUI() : m_bHorizontal(true), m_nMin(0), m_nMax(100), m_nValue(0)
{
m_uTextStyle = DT_SINGLELINE | DT_CENTER;
SetFixedHeight(12);
}
LPCTSTR CProgressUI::GetClass() const
{
return _T("ProgressUI");
}
LPVOID CProgressUI::GetInterface(LPCTSTR pstrName)
{
if( _tcscmp(pstrName, _T("Progress")) == 0 ) return static_cast<CProgressUI*>(this);
return CLabelUI::GetInterface(pstrName);
}
bool CProgressUI::IsHorizontal()
{
return m_bHorizontal;
}
void CProgressUI::SetHorizontal(bool bHorizontal)
{
if( m_bHorizontal == bHorizontal ) return;
m_bHorizontal = bHorizontal;
Invalidate();
}
int CProgressUI::GetMinValue() const
{
return m_nMin;
}
void CProgressUI::SetMinValue(int nMin)
{
m_nMin = nMin;
Invalidate();
}
int CProgressUI::GetMaxValue() const
{
return m_nMax;
}
void CProgressUI::SetMaxValue(int nMax)
{
m_nMax = nMax;
Invalidate();
}
int CProgressUI::GetValue() const
{
return m_nValue;
}
void CProgressUI::SetValue(int nValue)
{
m_nValue = nValue;
Invalidate();
}
LPCTSTR CProgressUI::GetForeImage() const
{
return m_sForeImage;
}
void CProgressUI::SetForeImage(LPCTSTR pStrImage)
{
if( m_sForeImage == pStrImage ) return;
m_sForeImage = pStrImage;
Invalidate();
}
void CProgressUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue)
{
if( _tcscmp(pstrName, _T("foreimage")) == 0 ) SetForeImage(pstrValue);
else if( _tcscmp(pstrName, _T("hor")) == 0 ) SetHorizontal(_tcscmp(pstrValue, _T("true")) == 0);
else if( _tcscmp(pstrName, _T("min")) == 0 ) SetMinValue(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("max")) == 0 ) SetMaxValue(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("value")) == 0 ) SetValue(_ttoi(pstrValue));
else CLabelUI::SetAttribute(pstrName, pstrValue);
}
void CProgressUI::PaintStatusImage(HDC hDC)
{
if( m_nMax <= m_nMin ) m_nMax = m_nMin + 1;
if( m_nValue > m_nMax ) m_nValue = m_nMax;
if( m_nValue < m_nMin ) m_nValue = m_nMin;
RECT rc = {0};
if( m_bHorizontal ) {
rc.right = (m_nValue - m_nMin) * (m_rcItem.right - m_rcItem.left) / (m_nMax - m_nMin);
rc.bottom = m_rcItem.bottom - m_rcItem.top;
}
else {
rc.top = (m_rcItem.bottom - m_rcItem.top) * (m_nMax - m_nValue) / (m_nMax - m_nMin);
rc.right = m_rcItem.right - m_rcItem.left;
rc.bottom = m_rcItem.bottom - m_rcItem.top;
}
if( !m_sForeImage.IsEmpty() ) {
m_sForeImageModify.Empty();
m_sForeImageModify.SmallFormat(_T("dest='%d,%d,%d,%d'"), rc.left, rc.top, rc.right, rc.bottom);
if( !DrawImage(hDC, (LPCTSTR)m_sForeImage, (LPCTSTR)m_sForeImageModify) ) m_sForeImage.Empty();
else return;
}
}
/////////////////////////////////////////////////////////////////////////////////////
//
//
CSliderUI::CSliderUI() : m_uButtonState(0), m_nStep(1)
{
m_uTextStyle = DT_SINGLELINE | DT_CENTER;
m_szThumb.cx = m_szThumb.cy = 10;
}
LPCTSTR CSliderUI::GetClass() const
{
return _T("SliderUI");
}
UINT CSliderUI::GetControlFlags() const
{
if( IsEnabled() ) return UIFLAG_SETCURSOR;
else return 0;
}
LPVOID CSliderUI::GetInterface(LPCTSTR pstrName)
{
if( _tcscmp(pstrName, _T("Slider")) == 0 ) return static_cast<CSliderUI*>(this);
return CProgressUI::GetInterface(pstrName);
}
void CSliderUI::SetEnabled(bool bEnable)
{
CControlUI::SetEnabled(bEnable);
if( !IsEnabled() ) {
m_uButtonState = 0;
}
}
int CSliderUI::GetChangeStep()
{
return m_nStep;
}
void CSliderUI::SetChangeStep(int step)
{
m_nStep = step;
}
void CSliderUI::SetThumbSize(SIZE szXY)
{
m_szThumb = szXY;
}
RECT CSliderUI::GetThumbRect() const
{
if( m_bHorizontal ) {
int left = m_rcItem.left + (m_rcItem.right - m_rcItem.left - m_szThumb.cx) * (m_nValue - m_nMin) / (m_nMax - m_nMin);
int top = (m_rcItem.bottom + m_rcItem.top - m_szThumb.cy) / 2;
return CRect(left, top, left + m_szThumb.cx, top + m_szThumb.cy);
}
else {
int left = (m_rcItem.right + m_rcItem.left - m_szThumb.cx) / 2;
int top = m_rcItem.bottom - m_szThumb.cy - (m_rcItem.bottom - m_rcItem.top - m_szThumb.cy) * (m_nValue - m_nMin) / (m_nMax - m_nMin);
return CRect(left, top, left + m_szThumb.cx, top + m_szThumb.cy);
}
}
LPCTSTR CSliderUI::GetThumbImage() const
{
return m_sThumbImage;
}
void CSliderUI::SetThumbImage(LPCTSTR pStrImage)
{
m_sThumbImage = pStrImage;
Invalidate();
}
LPCTSTR CSliderUI::GetThumbHotImage() const
{
return m_sThumbHotImage;
}
void CSliderUI::SetThumbHotImage(LPCTSTR pStrImage)
{
m_sThumbHotImage = pStrImage;
Invalidate();
}
LPCTSTR CSliderUI::GetThumbPushedImage() const
{
return m_sThumbPushedImage;
}
void CSliderUI::SetThumbPushedImage(LPCTSTR pStrImage)
{
m_sThumbPushedImage = pStrImage;
Invalidate();
}
void CSliderUI::DoEvent(TEventUI& event)
{
if( !IsMouseEnabled() && event.Type > UIEVENT__MOUSEBEGIN && event.Type < UIEVENT__MOUSEEND ) {
if( m_pParent != NULL ) m_pParent->DoEvent(event);
else CProgressUI::DoEvent(event);
return;
}
if( event.Type == UIEVENT_BUTTONDOWN || event.Type == UIEVENT_DBLCLICK )
{
if( IsEnabled() ) {
RECT rcThumb = GetThumbRect();
if( ::PtInRect(&rcThumb, event.ptMouse) ) {
m_uButtonState |= UISTATE_CAPTURED;
}
}
return;
}
if( event.Type == UIEVENT_BUTTONUP )
{
if( (m_uButtonState & UISTATE_CAPTURED) != 0 ) {
m_uButtonState &= ~UISTATE_CAPTURED;
}
if( m_bHorizontal ) {
if( event.ptMouse.x >= m_rcItem.right - m_szThumb.cx / 2 ) m_nValue = m_nMax;
else if( event.ptMouse.x <= m_rcItem.left + m_szThumb.cx / 2 ) m_nValue = m_nMin;
else m_nValue = m_nMin + (m_nMax - m_nMin) * (event.ptMouse.x - m_rcItem.left - m_szThumb.cx / 2 ) / (m_rcItem.right - m_rcItem.left - m_szThumb.cx);
}
else {
if( event.ptMouse.y >= m_rcItem.bottom - m_szThumb.cy / 2 ) m_nValue = m_nMin;
else if( event.ptMouse.y <= m_rcItem.top + m_szThumb.cy / 2 ) m_nValue = m_nMax;
else m_nValue = m_nMin + (m_nMax - m_nMin) * (m_rcItem.bottom - event.ptMouse.y - m_szThumb.cy / 2 ) / (m_rcItem.bottom - m_rcItem.top - m_szThumb.cy);
}
m_pManager->SendNotify(this, _T("valuechanged"));
Invalidate();
return;
}
if( event.Type == UIEVENT_CONTEXTMENU )
{
return;
}
if( event.Type == UIEVENT_SCROLLWHEEL )
{
switch( LOWORD(event.wParam) ) {
case SB_LINEUP:
SetValue(GetValue() + GetChangeStep());
m_pManager->SendNotify(this, _T("valuechanged"));
return;
case SB_LINEDOWN:
SetValue(GetValue() - GetChangeStep());
m_pManager->SendNotify(this, _T("valuechanged"));
return;
}
}
if( event.Type == UIEVENT_MOUSEMOVE )
{
if( (m_uButtonState & UISTATE_CAPTURED) != 0 ) {
if( m_bHorizontal ) {
if( event.ptMouse.x >= m_rcItem.right - m_szThumb.cx / 2 ) m_nValue = m_nMax;
else if( event.ptMouse.x <= m_rcItem.left + m_szThumb.cx / 2 ) m_nValue = m_nMin;
else m_nValue = m_nMin + (m_nMax - m_nMin) * (event.ptMouse.x - m_rcItem.left - m_szThumb.cx / 2 ) / (m_rcItem.right - m_rcItem.left - m_szThumb.cx);
}
else {
if( event.ptMouse.y >= m_rcItem.bottom - m_szThumb.cy / 2 ) m_nValue = m_nMin;
else if( event.ptMouse.y <= m_rcItem.top + m_szThumb.cy / 2 ) m_nValue = m_nMax;
else m_nValue = m_nMin + (m_nMax - m_nMin) * (m_rcItem.bottom - event.ptMouse.y - m_szThumb.cy / 2 ) / (m_rcItem.bottom - m_rcItem.top - m_szThumb.cy);
}
Invalidate();
}
return;
}
if( event.Type == UIEVENT_SETCURSOR )
{
RECT rcThumb = GetThumbRect();
if( IsEnabled() && ::PtInRect(&rcThumb, event.ptMouse) ) {
::SetCursor(::LoadCursor(NULL, MAKEINTRESOURCE(IDC_HAND)));
return;
}
}
if( event.Type == UIEVENT_MOUSEENTER )
{
if( IsEnabled() ) {
m_uButtonState |= UISTATE_HOT;
Invalidate();
}
return;
}
if( event.Type == UIEVENT_MOUSELEAVE )
{
if( IsEnabled() ) {
m_uButtonState &= ~UISTATE_HOT;
Invalidate();
}
return;
}
CControlUI::DoEvent(event);
}
void CSliderUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue)
{
if( _tcscmp(pstrName, _T("thumbimage")) == 0 ) SetThumbImage(pstrValue);
else if( _tcscmp(pstrName, _T("thumbhotimage")) == 0 ) SetThumbHotImage(pstrValue);
else if( _tcscmp(pstrName, _T("thumbpushedimage")) == 0 ) SetThumbPushedImage(pstrValue);
else if( _tcscmp(pstrName, _T("thumbsize")) == 0 ) {
SIZE szXY = {0};
LPTSTR pstr = NULL;
szXY.cx = _tcstol(pstrValue, &pstr, 10); ASSERT(pstr);
szXY.cy = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
SetThumbSize(szXY);
}
else if( _tcscmp(pstrName, _T("step")) == 0 ) {
SetChangeStep(_ttoi(pstrValue));
}
else CProgressUI::SetAttribute(pstrName, pstrValue);
}
void CSliderUI::PaintStatusImage(HDC hDC)
{
CProgressUI::PaintStatusImage(hDC);
RECT rcThumb = GetThumbRect();
rcThumb.left -= m_rcItem.left;
rcThumb.top -= m_rcItem.top;
rcThumb.right -= m_rcItem.left;
rcThumb.bottom -= m_rcItem.top;
if( (m_uButtonState & UISTATE_CAPTURED) != 0 ) {
if( !m_sThumbPushedImage.IsEmpty() ) {
m_sImageModify.Empty();
m_sImageModify.SmallFormat(_T("dest='%d,%d,%d,%d'"), rcThumb.left, rcThumb.top, rcThumb.right, rcThumb.bottom);
if( !DrawImage(hDC, (LPCTSTR)m_sThumbPushedImage, (LPCTSTR)m_sImageModify) ) m_sThumbPushedImage.Empty();
else return;
}
}
else if( (m_uButtonState & UISTATE_HOT) != 0 ) {
if( !m_sThumbHotImage.IsEmpty() ) {
m_sImageModify.Empty();
m_sImageModify.SmallFormat(_T("dest='%d,%d,%d,%d'"), rcThumb.left, rcThumb.top, rcThumb.right, rcThumb.bottom);
if( !DrawImage(hDC, (LPCTSTR)m_sThumbHotImage, (LPCTSTR)m_sImageModify) ) m_sThumbHotImage.Empty();
else return;
}
}
if( !m_sThumbImage.IsEmpty() ) {
m_sImageModify.Empty();
m_sImageModify.SmallFormat(_T("dest='%d,%d,%d,%d'"), rcThumb.left, rcThumb.top, rcThumb.right, rcThumb.bottom);
if( !DrawImage(hDC, (LPCTSTR)m_sThumbImage, (LPCTSTR)m_sImageModify) ) m_sThumbImage.Empty();
else return;
}
}
/////////////////////////////////////////////////////////////////////////////////////
//
//
class CEditWnd : public CWindowWnd
{
public:
CEditWnd();
void Init(CEditUI* pOwner);
RECT CalPos();
LPCTSTR GetWindowClassName() const;
LPCTSTR GetSuperClassName() const;
void OnFinalMessage(HWND hWnd);
LRESULT HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);
LRESULT OnKillFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
LRESULT OnEditChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
protected:
CEditUI* m_pOwner;
HBRUSH m_hBkBrush;
bool m_bInit;
};
CEditWnd::CEditWnd() : m_pOwner(NULL), m_hBkBrush(NULL), m_bInit(false)
{
}
void CEditWnd::Init(CEditUI* pOwner)
{
m_pOwner = pOwner;
RECT rcPos = CalPos();
UINT uStyle = WS_CHILD | ES_AUTOHSCROLL;
if( m_pOwner->IsPasswordMode() ) uStyle |= ES_PASSWORD;
Create(m_pOwner->GetManager()->GetPaintWindow(), NULL, uStyle, 0, rcPos);
SetWindowFont(m_hWnd, m_pOwner->GetManager()->GetFontInfo(m_pOwner->GetFont())->hFont, TRUE);
Edit_LimitText(m_hWnd, m_pOwner->GetMaxChar());
if( m_pOwner->IsPasswordMode() ) Edit_SetPasswordChar(m_hWnd, m_pOwner->GetPasswordChar());
Edit_SetText(m_hWnd, m_pOwner->GetText());
Edit_SetModify(m_hWnd, FALSE);
SendMessage(EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELPARAM(0, 0));
Edit_Enable(m_hWnd, m_pOwner->IsEnabled() == true);
Edit_SetReadOnly(m_hWnd, m_pOwner->IsReadOnly() == true);
::ShowWindow(m_hWnd, SW_SHOWNOACTIVATE);
::SetFocus(m_hWnd);
m_bInit = true;
}
RECT CEditWnd::CalPos()
{
CRect rcPos = m_pOwner->GetPos();
RECT rcInset = m_pOwner->GetTextPadding();
rcPos.left += rcInset.left;
rcPos.top += rcInset.top;
rcPos.right -= rcInset.right;
rcPos.bottom -= rcInset.bottom;
LONG lEditHeight = m_pOwner->GetManager()->GetFontInfo(m_pOwner->GetFont())->tm.tmHeight;
if( lEditHeight < rcPos.GetHeight() ) {
rcPos.top += (rcPos.GetHeight() - lEditHeight) / 2;
rcPos.bottom = rcPos.top + lEditHeight;
}
return rcPos;
}
LPCTSTR CEditWnd::GetWindowClassName() const
{
return _T("EditWnd");
}
LPCTSTR CEditWnd::GetSuperClassName() const
{
return WC_EDIT;
}
void CEditWnd::OnFinalMessage(HWND /*hWnd*/)
{
// Clear reference and die
if( m_hBkBrush != NULL ) ::DeleteObject(m_hBkBrush);
m_pOwner->m_pWindow = NULL;
delete this;
}
LRESULT CEditWnd::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LRESULT lRes = 0;
BOOL bHandled = TRUE;
if( uMsg == WM_KILLFOCUS ) lRes = OnKillFocus(uMsg, wParam, lParam, bHandled);
else if( uMsg == OCM_COMMAND ) {
if( GET_WM_COMMAND_CMD(wParam, lParam) == EN_CHANGE ) lRes = OnEditChanged(uMsg, wParam, lParam, bHandled);
else if( GET_WM_COMMAND_CMD(wParam, lParam) == EN_UPDATE ) {
RECT rcClient;
::GetClientRect(m_hWnd, &rcClient);
::InvalidateRect(m_hWnd, &rcClient, FALSE);
}
}
else if( uMsg == WM_KEYDOWN && TCHAR(wParam) == VK_RETURN ) {
m_pOwner->GetManager()->SendNotify(m_pOwner, _T("return"));
}
else if( uMsg == OCM__BASE + WM_CTLCOLOREDIT || uMsg == OCM__BASE + WM_CTLCOLORSTATIC ) {
if( m_pOwner->GetNativeEditBkColor() == 0xFFFFFFFF ) return NULL;
::SetBkMode((HDC)wParam, TRANSPARENT);
DWORD dwTextColor = m_pOwner->GetTextColor();
::SetTextColor((HDC)wParam, RGB(GetBValue(dwTextColor),GetGValue(dwTextColor),GetRValue(dwTextColor)));
if( m_hBkBrush == NULL ) {
DWORD clrColor = m_pOwner->GetNativeEditBkColor();
m_hBkBrush = ::CreateSolidBrush(RGB(GetBValue(clrColor), GetGValue(clrColor), GetRValue(clrColor)));
}
return (LRESULT)m_hBkBrush;
}
else bHandled = FALSE;
if( !bHandled ) return CWindowWnd::HandleMessage(uMsg, wParam, lParam);
return lRes;
}
LRESULT CEditWnd::OnKillFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
LRESULT lRes = ::DefWindowProc(m_hWnd, uMsg, wParam, lParam);
PostMessage(WM_CLOSE);
return lRes;
}
LRESULT CEditWnd::OnEditChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
if( !m_bInit ) return 0;
if( m_pOwner == NULL ) return 0;
// Copy text back
int cchLen = ::GetWindowTextLength(m_hWnd) + 1;
LPTSTR pstr = static_cast<LPTSTR>(_alloca(cchLen * sizeof(TCHAR)));
ASSERT(pstr);
if( pstr == NULL ) return 0;
::GetWindowText(m_hWnd, pstr, cchLen);
m_pOwner->m_sText = pstr;
m_pOwner->GetManager()->SendNotify(m_pOwner, _T("textchanged"));
return 0;
}
/////////////////////////////////////////////////////////////////////////////////////
//
//
CEditUI::CEditUI() : m_pWindow(NULL), m_uMaxChar(255), m_bReadOnly(false),
m_bPasswordMode(false), m_cPasswordChar(_T('*')), m_uButtonState(0), m_dwEditbkColor(0xFFFFFFFF)
{
SetTextPadding(CRect(4, 3, 4, 3));
SetBkColor(0xFFFFFFFF);
}
LPCTSTR CEditUI::GetClass() const
{
return _T("EditUI");
}
LPVOID CEditUI::GetInterface(LPCTSTR pstrName)
{
if( _tcscmp(pstrName, _T("Edit")) == 0 ) return static_cast<CEditUI*>(this);
return CLabelUI::GetInterface(pstrName);
}
UINT CEditUI::GetControlFlags() const
{
if( !IsEnabled() ) return CControlUI::GetControlFlags();
return UIFLAG_SETCURSOR | UIFLAG_TABSTOP;
}
void CEditUI::DoEvent(TEventUI& event)
{
if( !IsMouseEnabled() && event.Type > UIEVENT__MOUSEBEGIN && event.Type < UIEVENT__MOUSEEND ) {
if( m_pParent != NULL ) m_pParent->DoEvent(event);
else CLabelUI::DoEvent(event);
return;
}
if( event.Type == UIEVENT_SETCURSOR && IsEnabled() )
{
::SetCursor(::LoadCursor(NULL, MAKEINTRESOURCE(IDC_IBEAM)));
return;
}
if( event.Type == UIEVENT_WINDOWSIZE )
{
if( m_pWindow != NULL ) m_pManager->SetFocusNeeded(this);
}
if( event.Type == UIEVENT_SCROLLWHEEL )
{
if( m_pWindow != NULL ) return;
}
if( event.Type == UIEVENT_SETFOCUS && IsEnabled() )
{
if( m_pWindow ) return;
m_pWindow = new CEditWnd();
ASSERT(m_pWindow);
m_pWindow->Init(this);
Invalidate();
}
if( event.Type == UIEVENT_KILLFOCUS && IsEnabled() )
{
Invalidate();
}
if( event.Type == UIEVENT_BUTTONDOWN || event.Type == UIEVENT_DBLCLICK || event.Type == UIEVENT_RBUTTONDOWN)
{
if( IsEnabled() ) {
GetManager()->ReleaseCapture();
if( IsFocused() && m_pWindow == NULL )
{
m_pWindow = new CEditWnd();
ASSERT(m_pWindow);
m_pWindow->Init(this);
if( PtInRect(&m_rcItem, event.ptMouse) )
{
int nSize = GetWindowTextLength(*m_pWindow);
if( nSize == 0 )
nSize = 1;
Edit_SetSel(*m_pWindow, 0, nSize);
}
}
else if( m_pWindow != NULL )
{
#if 1
int nSize = GetWindowTextLength(*m_pWindow);
if( nSize == 0 )
nSize = 1;
Edit_SetSel(*m_pWindow, 0, nSize);
#else
POINT pt = event.ptMouse;
pt.x -= m_rcItem.left + m_rcTextPadding.left;
pt.y -= m_rcItem.top + m_rcTextPadding.top;
::SendMessage(*m_pWindow, WM_LBUTTONDOWN, event.wParam, MAKELPARAM(pt.x, pt.y));
#endif
}
}
return;
}
if( event.Type == UIEVENT_MOUSEMOVE )
{
return;
}
if( event.Type == UIEVENT_BUTTONUP )
{
return;
}
if( event.Type == UIEVENT_CONTEXTMENU )
{
return;
}
if( event.Type == UIEVENT_MOUSEENTER )
{
if( IsEnabled() ) {
m_uButtonState |= UISTATE_HOT;
Invalidate();
}
return;
}
if( event.Type == UIEVENT_MOUSELEAVE )
{
if( IsEnabled() ) {
m_uButtonState &= ~UISTATE_HOT;
Invalidate();
}
return;
}
CLabelUI::DoEvent(event);
}
void CEditUI::SetEnabled(bool bEnable)
{
CControlUI::SetEnabled(bEnable);
if( !IsEnabled() ) {
m_uButtonState = 0;
}
}
void CEditUI::SetText(LPCTSTR pstrText)
{
m_sText = pstrText;
if( m_pWindow != NULL ) Edit_SetText(*m_pWindow, m_sText);
Invalidate();
}
void CEditUI::SetMaxChar(UINT uMax)
{
m_uMaxChar = uMax;
if( m_pWindow != NULL ) Edit_LimitText(*m_pWindow, m_uMaxChar);
}
UINT CEditUI::GetMaxChar()
{
return m_uMaxChar;
}
void CEditUI::SetReadOnly(bool bReadOnly)
{
if( m_bReadOnly == bReadOnly ) return;
m_bReadOnly = bReadOnly;
if( m_pWindow != NULL ) Edit_SetReadOnly(*m_pWindow, m_bReadOnly);
Invalidate();
}
bool CEditUI::IsReadOnly() const
{
return m_bReadOnly;
}
void CEditUI::SetPasswordMode(bool bPasswordMode)
{
if( m_bPasswordMode == bPasswordMode ) return;
m_bPasswordMode = bPasswordMode;
Invalidate();
}
bool CEditUI::IsPasswordMode() const
{
return m_bPasswordMode;
}
void CEditUI::SetPasswordChar(TCHAR cPasswordChar)
{
if( m_cPasswordChar == cPasswordChar ) return;
m_cPasswordChar = cPasswordChar;
if( m_pWindow != NULL ) Edit_SetPasswordChar(*m_pWindow, m_cPasswordChar);
Invalidate();
}
TCHAR CEditUI::GetPasswordChar() const
{
return m_cPasswordChar;
}
LPCTSTR CEditUI::GetNormalImage()
{
return m_sNormalImage;
}
void CEditUI::SetNormalImage(LPCTSTR pStrImage)
{
m_sNormalImage = pStrImage;
Invalidate();
}
LPCTSTR CEditUI::GetHotImage()
{
return m_sHotImage;
}
void CEditUI::SetHotImage(LPCTSTR pStrImage)
{
m_sHotImage = pStrImage;
Invalidate();
}
LPCTSTR CEditUI::GetFocusedImage()
{
return m_sFocusedImage;
}
void CEditUI::SetFocusedImage(LPCTSTR pStrImage)
{
m_sFocusedImage = pStrImage;
Invalidate();
}
LPCTSTR CEditUI::GetDisabledImage()
{
return m_sDisabledImage;
}
void CEditUI::SetDisabledImage(LPCTSTR pStrImage)
{
m_sDisabledImage = pStrImage;
Invalidate();
}
void CEditUI::SetNativeEditBkColor(DWORD dwBkColor)
{
m_dwEditbkColor = dwBkColor;
}
DWORD CEditUI::GetNativeEditBkColor() const
{
return m_dwEditbkColor;
}
void CEditUI::SetSel(long nStartChar, long nEndChar)
{
if( m_pWindow != NULL ) Edit_SetSel(*m_pWindow, nStartChar,nEndChar);
}
void CEditUI::SetSelAll()
{
SetSel(0,-1);
}
void CEditUI::SetReplaceSel(LPCTSTR lpszReplace)
{
if( m_pWindow != NULL ) Edit_ReplaceSel(*m_pWindow, lpszReplace);
}
void CEditUI::SetPos(RECT rc)
{
CControlUI::SetPos(rc);
if( m_pWindow != NULL ) {
RECT rcPos = m_pWindow->CalPos();
::SetWindowPos(m_pWindow->GetHWND(), NULL, rcPos.left, rcPos.top, rcPos.right - rcPos.left,
rcPos.bottom - rcPos.top, SWP_NOZORDER | SWP_NOACTIVATE);
}
}
void CEditUI::SetVisible(bool bVisible)
{
CControlUI::SetVisible(bVisible);
if( !IsVisible() && m_pWindow != NULL ) m_pManager->SetFocus(NULL);
}
void CEditUI::SetInternVisible(bool bVisible)
{
if( !IsVisible() && m_pWindow != NULL ) m_pManager->SetFocus(NULL);
}
SIZE CEditUI::EstimateSize(SIZE szAvailable)
{
if( m_cxyFixed.cy == 0 ) return CSize(m_cxyFixed.cx, m_pManager->GetFontInfo(GetFont())->tm.tmHeight + 6);
return CControlUI::EstimateSize(szAvailable);
}
void CEditUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue)
{
if( _tcscmp(pstrName, _T("readonly")) == 0 ) SetReadOnly(_tcscmp(pstrValue, _T("true")) == 0);
else if( _tcscmp(pstrName, _T("password")) == 0 ) SetPasswordMode(_tcscmp(pstrValue, _T("true")) == 0);
else if( _tcscmp(pstrName, _T("maxchar")) == 0 ) SetMaxChar(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("normalimage")) == 0 ) SetNormalImage(pstrValue);
else if( _tcscmp(pstrName, _T("hotimage")) == 0 ) SetHotImage(pstrValue);
else if( _tcscmp(pstrName, _T("focusedimage")) == 0 ) SetFocusedImage(pstrValue);
else if( _tcscmp(pstrName, _T("disabledimage")) == 0 ) SetDisabledImage(pstrValue);
else if( _tcscmp(pstrName, _T("nativebkcolor")) == 0 ) {
if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
LPTSTR pstr = NULL;
DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
SetNativeEditBkColor(clrColor);
}
else CLabelUI::SetAttribute(pstrName, pstrValue);
}
void CEditUI::PaintStatusImage(HDC hDC)
{
if( IsFocused() ) m_uButtonState |= UISTATE_FOCUSED;
else m_uButtonState &= ~ UISTATE_FOCUSED;
if( !IsEnabled() ) m_uButtonState |= UISTATE_DISABLED;
else m_uButtonState &= ~ UISTATE_DISABLED;
if( (m_uButtonState & UISTATE_DISABLED) != 0 ) {
if( !m_sDisabledImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sDisabledImage) ) m_sDisabledImage.Empty();
else return;
}
}
else if( (m_uButtonState & UISTATE_FOCUSED) != 0 ) {
if( !m_sFocusedImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sFocusedImage) ) m_sFocusedImage.Empty();
else return;
}
}
else if( (m_uButtonState & UISTATE_HOT) != 0 ) {
if( !m_sHotImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sHotImage) ) m_sHotImage.Empty();
else return;
}
}
if( !m_sNormalImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sNormalImage) ) m_sNormalImage.Empty();
else return;
}
}
void CEditUI::PaintText(HDC hDC)
{
if( m_dwTextColor == 0 ) m_dwTextColor = m_pManager->GetDefaultFontColor();
if( m_dwDisabledTextColor == 0 ) m_dwDisabledTextColor = m_pManager->GetDefaultDisabledColor();
if( m_sText.IsEmpty() ) return;
CStdString sText = m_sText;
if( m_bPasswordMode ) {
sText.Empty();
LPCTSTR p = m_sText.GetData();
while( *p != _T('\0') ) {
sText += m_cPasswordChar;
p = ::CharNext(p);
}
}
RECT rc = m_rcItem;
rc.left += m_rcTextPadding.left;
rc.right -= m_rcTextPadding.right;
rc.top += m_rcTextPadding.top;
rc.bottom -= m_rcTextPadding.bottom;
if( IsEnabled() ) {
CRenderEngine::DrawText(hDC, m_pManager, rc, sText, m_dwTextColor, \
m_iFont, DT_SINGLELINE | m_uTextStyle);
}
else {
CRenderEngine::DrawText(hDC, m_pManager, rc, sText, m_dwDisabledTextColor, \
m_iFont, DT_SINGLELINE | m_uTextStyle);
}
}
/////////////////////////////////////////////////////////////////////////////////////
//
//
CScrollBarUI::CScrollBarUI() : m_bHorizontal(false), m_nRange(100), m_nScrollPos(0), m_nLineSize(8),
m_pOwner(NULL), m_nLastScrollPos(0), m_nLastScrollOffset(0), m_nScrollRepeatDelay(0), m_uButton1State(0), \
m_uButton2State(0), m_uThumbState(0), m_bShowButton1(true), m_bShowButton2(true)
{
m_cxyFixed.cx = DEFAULT_SCROLLBAR_SIZE;
ptLastMouse.x = ptLastMouse.y = 0;
::ZeroMemory(&m_rcThumb, sizeof(m_rcThumb));
::ZeroMemory(&m_rcButton1, sizeof(m_rcButton1));
::ZeroMemory(&m_rcButton2, sizeof(m_rcButton2));
}
LPCTSTR CScrollBarUI::GetClass() const
{
return _T("ScrollBarUI");
}
LPVOID CScrollBarUI::GetInterface(LPCTSTR pstrName)
{
if( _tcscmp(pstrName, _T("ScrollBar")) == 0 ) return static_cast<CScrollBarUI*>(this);
return CControlUI::GetInterface(pstrName);
}
CContainerUI* CScrollBarUI::GetOwner() const
{
return m_pOwner;
}
void CScrollBarUI::SetOwner(CContainerUI* pOwner)
{
m_pOwner = pOwner;
}
void CScrollBarUI::SetVisible(bool bVisible)
{
if( m_bVisible == bVisible ) return;
bool v = IsVisible();
m_bVisible = bVisible;
if( m_bFocused ) m_bFocused = false;
}
void CScrollBarUI::SetEnabled(bool bEnable)
{
CControlUI::SetEnabled(bEnable);
if( !IsEnabled() ) {
m_uButton1State = 0;
m_uButton2State = 0;
m_uThumbState = 0;
}
}
void CScrollBarUI::SetFocus()
{
if( m_pOwner != NULL ) m_pOwner->SetFocus();
else CControlUI::SetFocus();
}
bool CScrollBarUI::IsHorizontal()
{
return m_bHorizontal;
}
void CScrollBarUI::SetHorizontal(bool bHorizontal)
{
if( m_bHorizontal == bHorizontal ) return;
m_bHorizontal = bHorizontal;
if( m_bHorizontal ) {
if( m_cxyFixed.cy == 0 ) {
m_cxyFixed.cx = 0;
m_cxyFixed.cy = DEFAULT_SCROLLBAR_SIZE;
}
}
else {
if( m_cxyFixed.cx == 0 ) {
m_cxyFixed.cx = DEFAULT_SCROLLBAR_SIZE;
m_cxyFixed.cy = 0;
}
}
if( m_pOwner != NULL ) m_pOwner->NeedUpdate(); else NeedParentUpdate();
}
int CScrollBarUI::GetScrollRange() const
{
return m_nRange;
}
void CScrollBarUI::SetScrollRange(int nRange)
{
if( m_nRange == nRange ) return;
m_nRange = nRange;
if( m_nRange < 0 ) m_nRange = 0;
if( m_nScrollPos > m_nRange ) m_nScrollPos = m_nRange;
SetPos(m_rcItem);
}
int CScrollBarUI::GetScrollPos() const
{
return m_nScrollPos;
}
void CScrollBarUI::SetScrollPos(int nPos)
{
if( m_nScrollPos == nPos ) return;
m_nScrollPos = nPos;
if( m_nScrollPos < 0 ) m_nScrollPos = 0;
if( m_nScrollPos > m_nRange ) m_nScrollPos = m_nRange;
SetPos(m_rcItem);
}
int CScrollBarUI::GetLineSize() const
{
return m_nLineSize;
}
void CScrollBarUI::SetLineSize(int nSize)
{
m_nLineSize = nSize;
}
bool CScrollBarUI::GetShowButton1()
{
return m_bShowButton1;
}
void CScrollBarUI::SetShowButton1(bool bShow)
{
m_bShowButton1 = bShow;
SetPos(m_rcItem);
}
LPCTSTR CScrollBarUI::GetButton1NormalImage()
{
return m_sButton1NormalImage;
}
void CScrollBarUI::SetButton1NormalImage(LPCTSTR pStrImage)
{
m_sButton1NormalImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetButton1HotImage()
{
return m_sButton1HotImage;
}
void CScrollBarUI::SetButton1HotImage(LPCTSTR pStrImage)
{
m_sButton1HotImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetButton1PushedImage()
{
return m_sButton1PushedImage;
}
void CScrollBarUI::SetButton1PushedImage(LPCTSTR pStrImage)
{
m_sButton1PushedImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetButton1DisabledImage()
{
return m_sButton1DisabledImage;
}
void CScrollBarUI::SetButton1DisabledImage(LPCTSTR pStrImage)
{
m_sButton1DisabledImage = pStrImage;
Invalidate();
}
bool CScrollBarUI::GetShowButton2()
{
return m_bShowButton2;
}
void CScrollBarUI::SetShowButton2(bool bShow)
{
m_bShowButton2 = bShow;
SetPos(m_rcItem);
}
LPCTSTR CScrollBarUI::GetButton2NormalImage()
{
return m_sButton2NormalImage;
}
void CScrollBarUI::SetButton2NormalImage(LPCTSTR pStrImage)
{
m_sButton2NormalImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetButton2HotImage()
{
return m_sButton2HotImage;
}
void CScrollBarUI::SetButton2HotImage(LPCTSTR pStrImage)
{
m_sButton2HotImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetButton2PushedImage()
{
return m_sButton2PushedImage;
}
void CScrollBarUI::SetButton2PushedImage(LPCTSTR pStrImage)
{
m_sButton2PushedImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetButton2DisabledImage()
{
return m_sButton2DisabledImage;
}
void CScrollBarUI::SetButton2DisabledImage(LPCTSTR pStrImage)
{
m_sButton2DisabledImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetThumbNormalImage()
{
return m_sThumbNormalImage;
}
void CScrollBarUI::SetThumbNormalImage(LPCTSTR pStrImage)
{
m_sThumbNormalImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetThumbHotImage()
{
return m_sThumbHotImage;
}
void CScrollBarUI::SetThumbHotImage(LPCTSTR pStrImage)
{
m_sThumbHotImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetThumbPushedImage()
{
return m_sThumbPushedImage;
}
void CScrollBarUI::SetThumbPushedImage(LPCTSTR pStrImage)
{
m_sThumbPushedImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetThumbDisabledImage()
{
return m_sThumbDisabledImage;
}
void CScrollBarUI::SetThumbDisabledImage(LPCTSTR pStrImage)
{
m_sThumbDisabledImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetRailNormalImage()
{
return m_sRailNormalImage;
}
void CScrollBarUI::SetRailNormalImage(LPCTSTR pStrImage)
{
m_sRailNormalImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetRailHotImage()
{
return m_sRailHotImage;
}
void CScrollBarUI::SetRailHotImage(LPCTSTR pStrImage)
{
m_sRailHotImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetRailPushedImage()
{
return m_sRailPushedImage;
}
void CScrollBarUI::SetRailPushedImage(LPCTSTR pStrImage)
{
m_sRailPushedImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetRailDisabledImage()
{
return m_sRailDisabledImage;
}
void CScrollBarUI::SetRailDisabledImage(LPCTSTR pStrImage)
{
m_sRailDisabledImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetBkNormalImage()
{
return m_sBkNormalImage;
}
void CScrollBarUI::SetBkNormalImage(LPCTSTR pStrImage)
{
m_sBkNormalImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetBkHotImage()
{
return m_sBkHotImage;
}
void CScrollBarUI::SetBkHotImage(LPCTSTR pStrImage)
{
m_sBkHotImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetBkPushedImage()
{
return m_sBkPushedImage;
}
void CScrollBarUI::SetBkPushedImage(LPCTSTR pStrImage)
{
m_sBkPushedImage = pStrImage;
Invalidate();
}
LPCTSTR CScrollBarUI::GetBkDisabledImage()
{
return m_sBkDisabledImage;
}
void CScrollBarUI::SetBkDisabledImage(LPCTSTR pStrImage)
{
m_sBkDisabledImage = pStrImage;
Invalidate();
}
void CScrollBarUI::SetPos(RECT rc)
{
CControlUI::SetPos(rc);
rc = m_rcItem;
if( m_bHorizontal ) {
int cx = rc.right - rc.left;
if( m_bShowButton1 ) cx -= m_cxyFixed.cy;
if( m_bShowButton2 ) cx -= m_cxyFixed.cy;
if( cx > m_cxyFixed.cy ) {
m_rcButton1.left = rc.left;
m_rcButton1.top = rc.top;
if( m_bShowButton1 ) {
m_rcButton1.right = rc.left + m_cxyFixed.cy;
m_rcButton1.bottom = rc.top + m_cxyFixed.cy;
}
else {
m_rcButton1.right = m_rcButton1.left;
m_rcButton1.bottom = m_rcButton1.top;
}
m_rcButton2.top = rc.top;
m_rcButton2.right = rc.right;
if( m_bShowButton2 ) {
m_rcButton2.left = rc.right - m_cxyFixed.cy;
m_rcButton2.bottom = rc.top + m_cxyFixed.cy;
}
else {
m_rcButton2.left = m_rcButton2.right;
m_rcButton2.bottom = m_rcButton2.top;
}
m_rcThumb.top = rc.top;
m_rcThumb.bottom = rc.top + m_cxyFixed.cy;
if( m_nRange > 0 ) {
int cxThumb = cx * (rc.right - rc.left) / (m_nRange + rc.right - rc.left);
if( cxThumb < m_cxyFixed.cy ) cxThumb = m_cxyFixed.cy;
m_rcThumb.left = m_nScrollPos * (cx - cxThumb) / m_nRange + m_rcButton1.right;
m_rcThumb.right = m_rcThumb.left + cxThumb;
if( m_rcThumb.right > m_rcButton2.left ) {
m_rcThumb.left = m_rcButton2.left - cxThumb;
m_rcThumb.right = m_rcButton2.left;
}
}
else {
m_rcThumb.left = m_rcButton1.right;
m_rcThumb.right = m_rcButton2.left;
}
}
else {
int cxButton = (rc.right - rc.left) / 2;
if( cxButton > m_cxyFixed.cy ) cxButton = m_cxyFixed.cy;
m_rcButton1.left = rc.left;
m_rcButton1.top = rc.top;
if( m_bShowButton1 ) {
m_rcButton1.right = rc.left + cxButton;
m_rcButton1.bottom = rc.top + m_cxyFixed.cy;
}
else {
m_rcButton1.right = m_rcButton1.left;
m_rcButton1.bottom = m_rcButton1.top;
}
m_rcButton2.top = rc.top;
m_rcButton2.right = rc.right;
if( m_bShowButton2 ) {
m_rcButton2.left = rc.right - cxButton;
m_rcButton2.bottom = rc.top + m_cxyFixed.cy;
}
else {
m_rcButton2.left = m_rcButton2.right;
m_rcButton2.bottom = m_rcButton2.top;
}
::ZeroMemory(&m_rcThumb, sizeof(m_rcThumb));
}
}
else {
int cy = rc.bottom - rc.top;
if( m_bShowButton1 ) cy -= m_cxyFixed.cx;
if( m_bShowButton2 ) cy -= m_cxyFixed.cx;
if( cy > m_cxyFixed.cx ) {
m_rcButton1.left = rc.left;
m_rcButton1.top = rc.top;
if( m_bShowButton1 ) {
m_rcButton1.right = rc.left + m_cxyFixed.cx;
m_rcButton1.bottom = rc.top + m_cxyFixed.cx;
}
else {
m_rcButton1.right = m_rcButton1.left;
m_rcButton1.bottom = m_rcButton1.top;
}
m_rcButton2.left = rc.left;
m_rcButton2.bottom = rc.bottom;
if( m_bShowButton2 ) {
m_rcButton2.top = rc.bottom - m_cxyFixed.cx;
m_rcButton2.right = rc.left + m_cxyFixed.cx;
}
else {
m_rcButton2.top = m_rcButton2.bottom;
m_rcButton2.right = m_rcButton2.left;
}
m_rcThumb.left = rc.left;
m_rcThumb.right = rc.left + m_cxyFixed.cx;
if( m_nRange > 0 ) {
int cyThumb = cy * (rc.bottom - rc.top) / (m_nRange + rc.bottom - rc.top);
if( cyThumb < m_cxyFixed.cx ) cyThumb = m_cxyFixed.cx;
m_rcThumb.top = m_nScrollPos * (cy - cyThumb) / m_nRange + m_rcButton1.bottom;
m_rcThumb.bottom = m_rcThumb.top + cyThumb;
if( m_rcThumb.bottom > m_rcButton2.top ) {
m_rcThumb.top = m_rcButton2.top - cyThumb;
m_rcThumb.bottom = m_rcButton2.top;
}
}
else {
m_rcThumb.top = m_rcButton1.bottom;
m_rcThumb.bottom = m_rcButton2.top;
}
}
else {
int cyButton = (rc.bottom - rc.top) / 2;
if( cyButton > m_cxyFixed.cx ) cyButton = m_cxyFixed.cx;
m_rcButton1.left = rc.left;
m_rcButton1.top = rc.top;
if( m_bShowButton1 ) {
m_rcButton1.right = rc.left + m_cxyFixed.cx;
m_rcButton1.bottom = rc.top + cyButton;
}
else {
m_rcButton1.right = m_rcButton1.left;
m_rcButton1.bottom = m_rcButton1.top;
}
m_rcButton2.left = rc.left;
m_rcButton2.bottom = rc.bottom;
if( m_bShowButton2 ) {
m_rcButton2.top = rc.bottom - cyButton;
m_rcButton2.right = rc.left + m_cxyFixed.cx;
}
else {
m_rcButton2.top = m_rcButton2.bottom;
m_rcButton2.right = m_rcButton2.left;
}
::ZeroMemory(&m_rcThumb, sizeof(m_rcThumb));
}
}
}
void CScrollBarUI::DoEvent(TEventUI& event)
{
if( !IsMouseEnabled() && event.Type > UIEVENT__MOUSEBEGIN && event.Type < UIEVENT__MOUSEEND ) {
if( m_pOwner != NULL ) m_pOwner->DoEvent(event);
else CControlUI::DoEvent(event);
return;
}
if( event.Type == UIEVENT_SETFOCUS )
{
return;
}
if( event.Type == UIEVENT_KILLFOCUS )
{
return;
}
if( event.Type == UIEVENT_BUTTONDOWN || event.Type == UIEVENT_DBLCLICK )
{
if( !IsEnabled() ) return;
m_nLastScrollOffset = 0;
m_nScrollRepeatDelay = 0;
m_pManager->SetTimer(this, DEFAULT_TIMERID, 50U);
if( ::PtInRect(&m_rcButton1, event.ptMouse) ) {
m_uButton1State |= UISTATE_PUSHED;
if( !m_bHorizontal ) {
if( m_pOwner != NULL ) m_pOwner->LineUp();
else SetScrollPos(m_nScrollPos - m_nLineSize);
}
else {
if( m_pOwner != NULL ) m_pOwner->LineLeft();
else SetScrollPos(m_nScrollPos - m_nLineSize);
}
}
else if( ::PtInRect(&m_rcButton2, event.ptMouse) ) {
m_uButton2State |= UISTATE_PUSHED;
if( !m_bHorizontal ) {
if( m_pOwner != NULL ) m_pOwner->LineDown();
else SetScrollPos(m_nScrollPos + m_nLineSize);
}
else {
if( m_pOwner != NULL ) m_pOwner->LineRight();
else SetScrollPos(m_nScrollPos + m_nLineSize);
}
}
else if( ::PtInRect(&m_rcThumb, event.ptMouse) ) {
m_uThumbState |= UISTATE_CAPTURED | UISTATE_PUSHED;
ptLastMouse = event.ptMouse;
m_nLastScrollPos = m_nScrollPos;
}
else {
if( !m_bHorizontal ) {
if( event.ptMouse.y < m_rcThumb.top ) {
if( m_pOwner != NULL ) m_pOwner->PageUp();
else SetScrollPos(m_nScrollPos + m_rcItem.top - m_rcItem.bottom);
}
else if ( event.ptMouse.y > m_rcThumb.bottom ){
if( m_pOwner != NULL ) m_pOwner->PageDown();
else SetScrollPos(m_nScrollPos - m_rcItem.top + m_rcItem.bottom);
}
}
else {
if( event.ptMouse.x < m_rcThumb.left ) {
if( m_pOwner != NULL ) m_pOwner->PageLeft();
else SetScrollPos(m_nScrollPos + m_rcItem.left - m_rcItem.right);
}
else if ( event.ptMouse.x > m_rcThumb.right ){
if( m_pOwner != NULL ) m_pOwner->PageRight();
else SetScrollPos(m_nScrollPos - m_rcItem.left + m_rcItem.right);
}
}
}
if( m_pManager != NULL && m_pOwner == NULL ) m_pManager->SendNotify(this, _T("scroll"));
return;
}
if( event.Type == UIEVENT_BUTTONUP )
{
m_nScrollRepeatDelay = 0;
m_nLastScrollOffset = 0;
m_pManager->KillTimer(this, DEFAULT_TIMERID);
if( (m_uThumbState & UISTATE_CAPTURED) != 0 ) {
m_uThumbState &= ~( UISTATE_CAPTURED | UISTATE_PUSHED );
Invalidate();
}
else if( (m_uButton1State & UISTATE_PUSHED) != 0 ) {
m_uButton1State &= ~UISTATE_PUSHED;
Invalidate();
}
else if( (m_uButton2State & UISTATE_PUSHED) != 0 ) {
m_uButton2State &= ~UISTATE_PUSHED;
Invalidate();
}
return;
}
if( event.Type == UIEVENT_MOUSEMOVE )
{
if( (m_uThumbState & UISTATE_CAPTURED) != 0 ) {
if( !m_bHorizontal ) {
m_nLastScrollOffset = (event.ptMouse.y - ptLastMouse.y) * m_nRange / \
(m_rcItem.bottom - m_rcItem.top - m_rcThumb.bottom + m_rcThumb.top - 2 * m_cxyFixed.cx);
}
else {
m_nLastScrollOffset = (event.ptMouse.x - ptLastMouse.x) * m_nRange / \
(m_rcItem.right - m_rcItem.left - m_rcThumb.right + m_rcThumb.left - 2 * m_cxyFixed.cy);
}
}
else {
if( (m_uThumbState & UISTATE_HOT) != 0 ) {
if( !::PtInRect(&m_rcThumb, event.ptMouse) ) {
m_uThumbState &= ~UISTATE_HOT;
Invalidate();
}
}
else {
if( !IsEnabled() ) return;
if( ::PtInRect(&m_rcThumb, event.ptMouse) ) {
m_uThumbState |= UISTATE_HOT;
Invalidate();
}
}
}
return;
}
if( event.Type == UIEVENT_CONTEXTMENU )
{
return;
}
if( event.Type == UIEVENT_TIMER && event.wParam == DEFAULT_TIMERID )
{
++m_nScrollRepeatDelay;
if( (m_uThumbState & UISTATE_CAPTURED) != 0 ) {
if( !m_bHorizontal ) {
if( m_pOwner != NULL ) m_pOwner->SetScrollPos(CSize(m_pOwner->GetScrollPos().cx, \
m_nLastScrollPos + m_nLastScrollOffset));
else SetScrollPos(m_nLastScrollPos + m_nLastScrollOffset);
}
else {
if( m_pOwner != NULL ) m_pOwner->SetScrollPos(CSize(m_nLastScrollPos + m_nLastScrollOffset, \
m_pOwner->GetScrollPos().cy));
else SetScrollPos(m_nLastScrollPos + m_nLastScrollOffset);
}
Invalidate();
}
else if( (m_uButton1State & UISTATE_PUSHED) != 0 ) {
if( m_nScrollRepeatDelay <= 5 ) return;
if( !m_bHorizontal ) {
if( m_pOwner != NULL ) m_pOwner->LineUp();
else SetScrollPos(m_nScrollPos - m_nLineSize);
}
else {
if( m_pOwner != NULL ) m_pOwner->LineLeft();
else SetScrollPos(m_nScrollPos - m_nLineSize);
}
}
else if( (m_uButton2State & UISTATE_PUSHED) != 0 ) {
if( m_nScrollRepeatDelay <= 5 ) return;
if( !m_bHorizontal ) {
if( m_pOwner != NULL ) m_pOwner->LineDown();
else SetScrollPos(m_nScrollPos + m_nLineSize);
}
else {
if( m_pOwner != NULL ) m_pOwner->LineRight();
else SetScrollPos(m_nScrollPos + m_nLineSize);
}
}
else {
if( m_nScrollRepeatDelay <= 5 ) return;
POINT pt = { 0 };
::GetCursorPos(&pt);
::ScreenToClient(m_pManager->GetPaintWindow(), &pt);
if( !m_bHorizontal ) {
if( pt.y < m_rcThumb.top ) {
if( m_pOwner != NULL ) m_pOwner->PageUp();
else SetScrollPos(m_nScrollPos + m_rcItem.top - m_rcItem.bottom);
}
else if ( pt.y > m_rcThumb.bottom ){
if( m_pOwner != NULL ) m_pOwner->PageDown();
else SetScrollPos(m_nScrollPos - m_rcItem.top + m_rcItem.bottom);
}
}
else {
if( pt.x < m_rcThumb.left ) {
if( m_pOwner != NULL ) m_pOwner->PageLeft();
else SetScrollPos(m_nScrollPos + m_rcItem.left - m_rcItem.right);
}
else if ( pt.x > m_rcThumb.right ){
if( m_pOwner != NULL ) m_pOwner->PageRight();
else SetScrollPos(m_nScrollPos - m_rcItem.left + m_rcItem.right);
}
}
}
if( m_pManager != NULL && m_pOwner == NULL ) m_pManager->SendNotify(this, _T("scroll"));
return;
}
if( event.Type == UIEVENT_MOUSEENTER )
{
if( IsEnabled() ) {
m_uButton1State |= UISTATE_HOT;
m_uButton2State |= UISTATE_HOT;
if( ::PtInRect(&m_rcThumb, event.ptMouse) ) m_uThumbState |= UISTATE_HOT;
Invalidate();
}
return;
}
if( event.Type == UIEVENT_MOUSELEAVE )
{
if( IsEnabled() ) {
m_uButton1State &= ~UISTATE_HOT;
m_uButton2State &= ~UISTATE_HOT;
m_uThumbState &= ~UISTATE_HOT;
Invalidate();
}
return;
}
if( m_pOwner != NULL ) m_pOwner->DoEvent(event); else CControlUI::DoEvent(event);
}
void CScrollBarUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue)
{
if( _tcscmp(pstrName, _T("button1normalimage")) == 0 ) SetButton1NormalImage(pstrValue);
else if( _tcscmp(pstrName, _T("button1hotimage")) == 0 ) SetButton1HotImage(pstrValue);
else if( _tcscmp(pstrName, _T("button1pushedimage")) == 0 ) SetButton1PushedImage(pstrValue);
else if( _tcscmp(pstrName, _T("button1disabledimage")) == 0 ) SetButton1DisabledImage(pstrValue);
else if( _tcscmp(pstrName, _T("button2normalimage")) == 0 ) SetButton2NormalImage(pstrValue);
else if( _tcscmp(pstrName, _T("button2hotimage")) == 0 ) SetButton2HotImage(pstrValue);
else if( _tcscmp(pstrName, _T("button2pushedimage")) == 0 ) SetButton2PushedImage(pstrValue);
else if( _tcscmp(pstrName, _T("button2disabledimage")) == 0 ) SetButton2DisabledImage(pstrValue);
else if( _tcscmp(pstrName, _T("thumbnormalimage")) == 0 ) SetThumbNormalImage(pstrValue);
else if( _tcscmp(pstrName, _T("thumbhotimage")) == 0 ) SetThumbHotImage(pstrValue);
else if( _tcscmp(pstrName, _T("thumbpushedimage")) == 0 ) SetThumbPushedImage(pstrValue);
else if( _tcscmp(pstrName, _T("thumbdisabledimage")) == 0 ) SetThumbDisabledImage(pstrValue);
else if( _tcscmp(pstrName, _T("railnormalimage")) == 0 ) SetRailNormalImage(pstrValue);
else if( _tcscmp(pstrName, _T("railhotimage")) == 0 ) SetRailHotImage(pstrValue);
else if( _tcscmp(pstrName, _T("railpushedimage")) == 0 ) SetRailPushedImage(pstrValue);
else if( _tcscmp(pstrName, _T("raildisabledimage")) == 0 ) SetRailDisabledImage(pstrValue);
else if( _tcscmp(pstrName, _T("bknormalimage")) == 0 ) SetBkNormalImage(pstrValue);
else if( _tcscmp(pstrName, _T("bkhotimage")) == 0 ) SetBkHotImage(pstrValue);
else if( _tcscmp(pstrName, _T("bkpushedimage")) == 0 ) SetBkPushedImage(pstrValue);
else if( _tcscmp(pstrName, _T("bkdisabledimage")) == 0 ) SetBkDisabledImage(pstrValue);
else if( _tcscmp(pstrName, _T("hor")) == 0 ) SetHorizontal(_tcscmp(pstrValue, _T("true")) == 0);
else if( _tcscmp(pstrName, _T("linesize")) == 0 ) SetLineSize(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("range")) == 0 ) SetScrollRange(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("value")) == 0 ) SetScrollPos(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("showbutton1")) == 0 ) SetShowButton1(_tcscmp(pstrValue, _T("true")) == 0);
else if( _tcscmp(pstrName, _T("showbutton2")) == 0 ) SetShowButton2(_tcscmp(pstrValue, _T("true")) == 0);
else CControlUI::SetAttribute(pstrName, pstrValue);
}
void CScrollBarUI::DoPaint(HDC hDC, const RECT& rcPaint)
{
if( !::IntersectRect(&m_rcPaint, &rcPaint, &m_rcItem) ) return;
PaintBk(hDC);
PaintButton1(hDC);
PaintButton2(hDC);
PaintThumb(hDC);
PaintRail(hDC);
}
void CScrollBarUI::PaintBk(HDC hDC)
{
if( !IsEnabled() ) m_uThumbState |= UISTATE_DISABLED;
else m_uThumbState &= ~ UISTATE_DISABLED;
if( (m_uThumbState & UISTATE_DISABLED) != 0 ) {
if( !m_sBkDisabledImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sBkDisabledImage) ) m_sBkDisabledImage.Empty();
else return;
}
}
else if( (m_uThumbState & UISTATE_PUSHED) != 0 ) {
if( !m_sBkPushedImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sBkPushedImage) ) m_sBkPushedImage.Empty();
else return;
}
}
else if( (m_uThumbState & UISTATE_HOT) != 0 ) {
if( !m_sBkHotImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sBkHotImage) ) m_sBkHotImage.Empty();
else return;
}
}
if( !m_sBkNormalImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sBkNormalImage) ) m_sBkNormalImage.Empty();
else return;
}
}
void CScrollBarUI::PaintButton1(HDC hDC)
{
if( !m_bShowButton1 ) return;
if( !IsEnabled() ) m_uButton1State |= UISTATE_DISABLED;
else m_uButton1State &= ~ UISTATE_DISABLED;
m_sImageModify.Empty();
m_sImageModify.SmallFormat(_T("dest='%d,%d,%d,%d'"), m_rcButton1.left - m_rcItem.left, \
m_rcButton1.top - m_rcItem.top, m_rcButton1.right - m_rcItem.left, m_rcButton1.bottom - m_rcItem.top);
if( (m_uButton1State & UISTATE_DISABLED) != 0 ) {
if( !m_sButton1DisabledImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sButton1DisabledImage, (LPCTSTR)m_sImageModify) ) m_sButton1DisabledImage.Empty();
else return;
}
}
else if( (m_uButton1State & UISTATE_PUSHED) != 0 ) {
if( !m_sButton1PushedImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sButton1PushedImage, (LPCTSTR)m_sImageModify) ) m_sButton1PushedImage.Empty();
else return;
}
}
else if( (m_uButton1State & UISTATE_HOT) != 0 ) {
if( !m_sButton1HotImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sButton1HotImage, (LPCTSTR)m_sImageModify) ) m_sButton1HotImage.Empty();
else return;
}
}
if( !m_sButton1NormalImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sButton1NormalImage, (LPCTSTR)m_sImageModify) ) m_sButton1NormalImage.Empty();
else return;
}
DWORD dwBorderColor = 0xFF85E4FF;
int nBorderSize = 2;
CRenderEngine::DrawRect(hDC, m_rcButton1, nBorderSize, dwBorderColor);
}
void CScrollBarUI::PaintButton2(HDC hDC)
{
if( !m_bShowButton2 ) return;
if( !IsEnabled() ) m_uButton2State |= UISTATE_DISABLED;
else m_uButton2State &= ~ UISTATE_DISABLED;
m_sImageModify.Empty();
m_sImageModify.SmallFormat(_T("dest='%d,%d,%d,%d'"), m_rcButton2.left - m_rcItem.left, \
m_rcButton2.top - m_rcItem.top, m_rcButton2.right - m_rcItem.left, m_rcButton2.bottom - m_rcItem.top);
if( (m_uButton2State & UISTATE_DISABLED) != 0 ) {
if( !m_sButton2DisabledImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sButton2DisabledImage, (LPCTSTR)m_sImageModify) ) m_sButton2DisabledImage.Empty();
else return;
}
}
else if( (m_uButton2State & UISTATE_PUSHED) != 0 ) {
if( !m_sButton2PushedImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sButton2PushedImage, (LPCTSTR)m_sImageModify) ) m_sButton2PushedImage.Empty();
else return;
}
}
else if( (m_uButton2State & UISTATE_HOT) != 0 ) {
if( !m_sButton2HotImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sButton2HotImage, (LPCTSTR)m_sImageModify) ) m_sButton2HotImage.Empty();
else return;
}
}
if( !m_sButton2NormalImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sButton2NormalImage, (LPCTSTR)m_sImageModify) ) m_sButton2NormalImage.Empty();
else return;
}
DWORD dwBorderColor = 0xFF85E4FF;
int nBorderSize = 2;
CRenderEngine::DrawRect(hDC, m_rcButton2, nBorderSize, dwBorderColor);
}
void CScrollBarUI::PaintThumb(HDC hDC)
{
if( m_rcThumb.left == 0 && m_rcThumb.top == 0 && m_rcThumb.right == 0 && m_rcThumb.bottom == 0 ) return;
if( !IsEnabled() ) m_uThumbState |= UISTATE_DISABLED;
else m_uThumbState &= ~ UISTATE_DISABLED;
m_sImageModify.Empty();
m_sImageModify.SmallFormat(_T("dest='%d,%d,%d,%d'"), m_rcThumb.left - m_rcItem.left, \
m_rcThumb.top - m_rcItem.top, m_rcThumb.right - m_rcItem.left, m_rcThumb.bottom - m_rcItem.top);
if( (m_uThumbState & UISTATE_DISABLED) != 0 ) {
if( !m_sThumbDisabledImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sThumbDisabledImage, (LPCTSTR)m_sImageModify) ) m_sThumbDisabledImage.Empty();
else return;
}
}
else if( (m_uThumbState & UISTATE_PUSHED) != 0 ) {
if( !m_sThumbPushedImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sThumbPushedImage, (LPCTSTR)m_sImageModify) ) m_sThumbPushedImage.Empty();
else return;
}
}
else if( (m_uThumbState & UISTATE_HOT) != 0 ) {
if( !m_sThumbHotImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sThumbHotImage, (LPCTSTR)m_sImageModify) ) m_sThumbHotImage.Empty();
else return;
}
}
if( !m_sThumbNormalImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sThumbNormalImage, (LPCTSTR)m_sImageModify) ) m_sThumbNormalImage.Empty();
else return;
}
DWORD dwBorderColor = 0xFF85E4FF;
int nBorderSize = 2;
CRenderEngine::DrawRect(hDC, m_rcThumb, nBorderSize, dwBorderColor);
}
void CScrollBarUI::PaintRail(HDC hDC)
{
if( m_rcThumb.left == 0 && m_rcThumb.top == 0 && m_rcThumb.right == 0 && m_rcThumb.bottom == 0 ) return;
if( !IsEnabled() ) m_uThumbState |= UISTATE_DISABLED;
else m_uThumbState &= ~ UISTATE_DISABLED;
m_sImageModify.Empty();
if( !m_bHorizontal ) {
m_sImageModify.SmallFormat(_T("dest='%d,%d,%d,%d'"), m_rcThumb.left - m_rcItem.left, \
(m_rcThumb.top + m_rcThumb.bottom) / 2 - m_rcItem.top - m_cxyFixed.cx / 2, \
m_rcThumb.right - m_rcItem.left, \
(m_rcThumb.top + m_rcThumb.bottom) / 2 - m_rcItem.top + m_cxyFixed.cx - m_cxyFixed.cx / 2);
}
else {
m_sImageModify.SmallFormat(_T("dest='%d,%d,%d,%d'"), \
(m_rcThumb.left + m_rcThumb.right) / 2 - m_rcItem.left - m_cxyFixed.cy / 2, \
m_rcThumb.top - m_rcItem.top, \
(m_rcThumb.left + m_rcThumb.right) / 2 - m_rcItem.left + m_cxyFixed.cy - m_cxyFixed.cy / 2, \
m_rcThumb.bottom - m_rcItem.top);
}
if( (m_uThumbState & UISTATE_DISABLED) != 0 ) {
if( !m_sRailDisabledImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sRailDisabledImage, (LPCTSTR)m_sImageModify) ) m_sRailDisabledImage.Empty();
else return;
}
}
else if( (m_uThumbState & UISTATE_PUSHED) != 0 ) {
if( !m_sRailPushedImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sRailPushedImage, (LPCTSTR)m_sImageModify) ) m_sRailPushedImage.Empty();
else return;
}
}
else if( (m_uThumbState & UISTATE_HOT) != 0 ) {
if( !m_sRailHotImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sRailHotImage, (LPCTSTR)m_sImageModify) ) m_sRailHotImage.Empty();
else return;
}
}
if( !m_sRailNormalImage.IsEmpty() ) {
if( !DrawImage(hDC, (LPCTSTR)m_sRailNormalImage, (LPCTSTR)m_sImageModify) ) m_sRailNormalImage.Empty();
else return;
}
}
} // namespace DuiLib
| [
"Johnny-Martin@users.noreply.github.com"
] | Johnny-Martin@users.noreply.github.com |
d23d6f559e5e9c44b513e6cff42c9cbf0f5e01ea | 7223467dee9729d6f891064a396513558714ca66 | /Program In CPP/helloworld.cpp | 125c586cb87e9a0dd75fc9ceb7229324561bb9b5 | [] | no_license | zaidajani/Hacktoberfest_2021-1 | c2be8d0a9e163a870726bb838055b4b4e526660f | 5675f9be7ab12510fdb0b962638905efed9372ca | refs/heads/main | 2023-09-04T12:04:01.865557 | 2021-10-30T06:18:42 | 2021-10-30T06:18:42 | 422,800,957 | 1 | 0 | null | 2021-10-30T06:17:39 | 2021-10-30T06:17:38 | null | UTF-8 | C++ | false | false | 96 | cpp | #include<iostream>
using namespace std;
int main(){
cout<<"Hello World!"<<endl;
return 0;
}
| [
"noreply@github.com"
] | zaidajani.noreply@github.com |
c675e2e6ee9be13823bc18735acb2e82492710cd | 4c23be1a0ca76f68e7146f7d098e26c2bbfb2650 | /ic8h18/0.0005/NEOC6KETGF | 6816ad683bbab605c0eaafc3de75771a3506fb69 | [] | no_license | labsandy/OpenFOAM_workspace | a74b473903ddbd34b31dc93917e3719bc051e379 | 6e0193ad9dabd613acf40d6b3ec4c0536c90aed4 | refs/heads/master | 2022-02-25T02:36:04.164324 | 2019-08-23T02:27:16 | 2019-08-23T02:27:16 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 843 | /*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: 6
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0.0005";
object NEOC6KETGF;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 0 0 0 0];
internalField uniform 1.45073e-21;
boundaryField
{
boundary
{
type empty;
}
}
// ************************************************************************* //
| [
"jfeatherstone123@gmail.com"
] | jfeatherstone123@gmail.com | |
26b8bcae1ce6a7c4a10a03651b0e423b81822fa9 | 903767e9e1bd7ae4c273621f2787e8e93ed38553 | /Codeforces/Div2/785/F.cpp | ffecec80ce9e4b0fa2159a34b269009acbc5db2c | [] | no_license | itohdak/Competitive_Programming | 609e6a9e17a4fa21b8f3f7fc9bbc13204d7f7ac4 | e14ab7a92813755d97a85be4ead68620753a6d4b | refs/heads/master | 2023-08-04T08:57:55.546063 | 2023-08-01T21:09:28 | 2023-08-01T21:09:28 | 304,704,923 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,470 | cpp | #include <bits/stdc++.h>
#include <print.hpp>
using namespace std;
#define ll long long
#define ld long double
#define REP(i,m,n) for(int i=(int)(m); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define RREP(i,m,n) for(int i=(int)(m); i>=(int)(n); i--)
#define rrep(i,n) RREP(i,(n)-1,0)
#define all(v) v.begin(), v.end()
#define endk '\n'
const int inf = 1e9+7;
const ll longinf = 1LL<<60;
const ll mod = 1e9+7;
const ll mod2 = 998244353;
const ld eps = 1e-10;
template<typename T1, typename T2> inline void chmin(T1 &a, T2 b){if(a>b) a=b;}
template<typename T1, typename T2> inline void chmax(T1 &a, T2 b){if(a<b) a=b;}
void solve() {
int n, k; cin >> n >> k;
vector<vector<int>> A(n, vector<int>(n));
int tmp = 0;
map<int, pair<int, int>> mp;
rep(i, n) rep(j, n) {
A[i][j] = tmp;
mp[tmp] = {i, j};
tmp++;
}
ll sum = 0;
rep(i, n) {
rep(j, n-1) {
cout << (A[i][j]^A[i][j+1]) << ' ';
sum += (A[i][j]^A[i][j+1]);
}
cout << endk;
}
rep(i, n-1) {
rep(j, n) {
cout << (A[i][j]^A[i+1][j]) << ' ';
sum += (A[i][j]^A[i+1][j]);
}
if(i == n-2) cout << endl;
else cout << endk;
}
// cout << sum << endl;
int cur = 0;
rep(i, k) {
int in; cin >> in;
int next = cur ^ in;
auto [x, y] = mp[next];
cout << x+1 << ' ' << y+1 << endl;
cur = next;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int T = 1;
// cin >> T;
while(T--) solve();
return 0;
}
| [
"itohdak@gmail.com"
] | itohdak@gmail.com |
a9c4a3cb3317fc9e2610cf630115a17158475fb4 | 8d6d787de31695ce6c0914b17b843e870303abb9 | /ImageFilterC++/ImageFilterC++/ImageFilter/Textures/CloudsTexture.h | c4353d32afa02d2ea61e3bbf5347f1192a6a827c | [] | no_license | laloli/ImageFilterC | 15527da4858ee0b2b67b08a0c54c4cd0b776ebac | 617dd34c816fa9c55a3a83a3806bb0a8948ab947 | refs/heads/master | 2021-01-12T14:46:21.035764 | 2012-07-17T05:41:09 | 2012-07-17T05:41:09 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 2,238 | h | /*
* HaoRan ImageFilter Classes v0.4
* Copyright (C) 2012 Zhenjun Dai
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by the
* Free Software Foundation; either version 2.1 of the License, or (at your
* option) any later version.
*
* This 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 GNU Lesser General Public License
* for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; if not, write to the Free Software Foundation.
*/
#if !defined(CloudsTextureH)
#define CloudsTextureH
#include <vector>
#include "PerlinNoise.h"
#include "../NoiseFilter.h"
#include "ITextureGenerator.h"
namespace HaoRan_ImageFilter{
class CloudsTexture : public ITextureGenerator{
private:
int r;
public:
CloudsTexture()
{
Reset();
};
/// <summary>
/// Generate texture
/// </summary>
///
/// <param name="width">Texture's width</param>
/// <param name="height">Texture's height</param>
///
/// <returns>Two dimensional array of intensities</returns>
///
/// <remarks>Generates new texture with specified dimension.</remarks>
///
virtual vector<vector<float>> Generate( int width, int height )
{
// Perlin noise function used for texture generation
PerlinNoise noise( 1.0 / 32, 1.0, 0.5, 8 );
// randmom number generator
//使用vector模拟二维动态数组
vector<vector<float>> texture(height);
for(int x = 0; x < height ; x++) {
texture[x].resize(width);
}
for ( int y = 0; y < height; y++ )
{
for ( int x = 0; x < width; x++ )
{
texture[y][x] =
max( 0.0f, min( 1.0f,
(float) noise.Function2D( x + r, y + r ) * 0.5f + 0.5f
) );
}
}
return texture;
};
/// <summary>
/// Reset generator
/// </summary>
///
/// <remarks>Regenerates internal random numbers.</remarks>
///
virtual void Reset( )
{
r = NoiseFilter::getRandomInt(1, 5000);
}
};
}// namespace HaoRan
#endif
| [
"daizhj@gmail.com"
] | daizhj@gmail.com |
c125442c0cd57c4d4672813fa8ff582ecfdbb259 | 3f7a258233ce1c88fe91feb7b4cd17437e8e6a9e | /vertexData.h | 0a332f8a999d9733a5af958d799a90006f65c915 | [] | no_license | VesaVirt4nen/VulkanObjectRenderer | 364768facf3faabbfef4122154c645531f7ce6c8 | 683a31aaf744f7f9d9bb71ba43a3d5e48b085753 | refs/heads/master | 2023-02-12T02:58:02.054364 | 2021-01-15T15:33:02 | 2021-01-15T15:33:02 | 327,652,819 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 611 | h | #ifndef VERTEXDATA
#define VERTEXDATA
#include <glm.hpp>
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtx/hash.hpp>
struct vertexData {
public:
glm::vec3 pos;
glm::vec2 texCoord;
glm::vec3 color;
bool operator==(const vertexData& other) const {
return pos == other.pos && color == other.color && texCoord == other.texCoord;
}
};
namespace std {
template<> struct hash<vertexData> {
size_t operator()(vertexData const& vertex) const {
return ((hash<glm::vec3>()(vertex.pos) ^
(hash<glm::vec3>()(vertex.color) << 1)) >> 1) ^
(hash<glm::vec2>()(vertex.texCoord) << 1);
}
};
}
#endif
| [
"vesa.virtanen@hotmaik.com"
] | vesa.virtanen@hotmaik.com |
73515ffbb9c16a4e298f6fea87266b83e3d6f5e9 | 71dfe3869c8d3528c6c587dc6f68682c0f2b1205 | /sort함수2.cpp | 9fa180acbe36d1ef32443b48ef7d00433643f775 | [] | no_license | nohtaegeuk/SW_LECTURE | b2e7959c9cd1750137be95c004ab0a058039f9de | e4061dc66a9b69005e5edeadeb4f604138a68a5f | refs/heads/main | 2023-04-17T07:59:59.429383 | 2021-05-06T05:55:38 | 2021-05-06T05:55:38 | 325,008,827 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 671 | cpp | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(void) {
vector < pair < int, string > > v;
//pair는 쌍을 의미. int와 string이 쌍을 이룬다는 의미.
v.push_back(pair<int, string>(90, "박한울"));
v.push_back(pair<int, string>(85, "이태일"));
v.push_back(pair<int, string>(82, "나동빈"));
v.push_back(pair<int, string>(98, "강종구"));
v.push_back(pair<int, string>(79, "이상욱"));
sort(v.begin(), v.end());
for(int i=0 ; i < v.size(); i++){
cout << v[i].second << ' '; // second은 pair안에 두번쨰 인자를 의미.
}
return 0;
}
| [
"noreply@github.com"
] | nohtaegeuk.noreply@github.com |
c68fb3d31aad35833522ecc2e42ce882059dd2e2 | 898d977587c06809002cdc86cc66121fba32cc8e | /owGame/WMO/WMO_Part_Fog.cpp | f051d2125e70be35ed453518a2549ff24897270b | [
"Apache-2.0"
] | permissive | websolution10030/OpenWow | e301248ec460059d3389cd8fd3e9da4db7e3af28 | 84a5539c1f1993484ca60f56974d7c8217061922 | refs/heads/master | 2023-06-06T01:24:05.615319 | 2021-06-25T00:29:19 | 2021-06-25T00:29:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 694 | cpp | #include "stdafx.h"
#ifdef USE_WMO_MODELS
// General
#include "Wmo_Part_Fog.h"
WMO_Part_Fog::WMO_Part_Fog(const SWMO_FogDef& WMOFogProto)
: m_WMOFogProto(WMOFogProto)
{
color = glm::vec4(m_WMOFogProto.fog.color.r, m_WMOFogProto.fog.color.g, m_WMOFogProto.fog.color.b, m_WMOFogProto.fog.color.a);
m_WMOFogProto.position = Fix_XZmY(m_WMOFogProto.position);
m_WMOFogProto.fog.startScalar = m_WMOFogProto.fog.startScalar * m_WMOFogProto.fog.end;
}
void WMO_Part_Fog::setup()
{
/*if (_Config.drawfog)
{
glFogfv(GL_FOG_COLOR, color);
glFogf(GL_FOG_START, fogDef.fog.startScalar);
glFogf(GL_FOG_END, fogDef.fog.end);
glEnable(GL_FOG);
}
else
{
glDisable(GL_FOG);
}*/
}
#endif | [
"alexstenfard@gmail.com"
] | alexstenfard@gmail.com |
879e0eeaa52da2452ccd521b39ea8e01f432799d | d09945668f19bb4bc17087c0cb8ccbab2b2dd688 | /yuki/2001-2100/2011.cpp | 01c58e19e6fbdae5a8c861b87a224b8dfefce66b | [] | no_license | kmjp/procon | 27270f605f3ae5d80fbdb28708318a6557273a57 | 8083028ece4be1460150aa3f0e69bdb57e510b53 | refs/heads/master | 2023-09-04T11:01:09.452170 | 2023-09-03T15:25:21 | 2023-09-03T15:25:21 | 30,825,508 | 23 | 2 | null | 2023-08-18T14:02:07 | 2015-02-15T11:25:23 | C++ | UTF-8 | C++ | false | false | 932 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define FORR2(x,y,arr) for(auto& [x,y]:arr)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
template<class T> bool chmax(T &a, const T &b) { if(a<b){a=b;return 1;}return 0;}
template<class T> bool chmin(T &a, const T &b) { if(a>b){a=b;return 1;}return 0;}
//-------------------------------------------------------
void solve() {
int i,j,k,l,r,x,y; string s;
ll M=3*5*17*65537;
cout<<M<<endl;
cout<<1<<endl;
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n'; FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
cout.tie(0); solve(); return 0;
}
| [
"kmjp@users.noreply.github.com"
] | kmjp@users.noreply.github.com |
b789bf9da578a5bbb57f2725766cca1100ec0681 | 1eb8dfa815ab711f06353520e6e895e88e02b872 | /jyro_accelerometer/angle_v9/angle_v9.cp | f817d508ffeeda4015afe48936c68a4d9437ae78 | [] | no_license | Simu3/RobotLog | bcd0319bfc5c787c5c7ee4a29d546d55c0080124 | 9c4aa2f5ca658cc57d2340ccfb9fdb614a84f0a3 | refs/heads/master | 2016-08-08T02:48:52.415656 | 2015-05-04T07:31:44 | 2015-05-04T07:31:44 | 35,020,633 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,386 | cp | #line 1 "C:/Users/i121326/Documents/workspace/robot/jyro_accelerometer/angle_v9/angle_v9.c"
#line 17 "C:/Users/i121326/Documents/workspace/robot/jyro_accelerometer/angle_v9/angle_v9.c"
void SetUp();
void OutPut(double, double);
void Debug(double, double);
void AcceleCheck(double, double, double);
char Dec2Ascii(char);
void Main()
{
double accele_x_bias = 0.0, accele_y_bias = 0.0;
double jyro_x_bias = 0.0, jyro_y_bias = 0.0;
double accele_x[2] = {0.0, 0.0};
double accele_y[2] = {0.0, 0.0};
double accele_z[2] = {0.0, 0.0};
double jyro_x = 0.0, jyro_y = 0.0;
double theta_x = 0.0, theta_y = 0.0;
double roll = 0.0, pitch = 0.0;
int i = 0;
SetUp();
for(i = 0; i < 100; i ++){
accele_x_bias += ADC_Read( 0 );
accele_y_bias += ADC_Read( 1 );
jyro_x_bias += ADC_Read( 3 );
jyro_y_bias += ADC_Read( 4 );
}
accele_x_bias /= 100.0;
accele_y_bias /= 100.0;
jyro_x_bias /= 100.0;
jyro_y_bias /= 100.0;
while(1){
do{
Output(0.0, 0.0);
Delay_ms(1);
}while( PORTB.B5 == 0);
accele_x[1] = accele_x[0];
accele_y[1] = accele_y[0];
accele_z[1] = accele_z[0];
TMR0 = 0;
accele_x[0] = (ADC_read( 0 ) - accele_x_bias) * (5.0 / 1024.0 * 1.0) ;
accele_y[0] = (ADC_read( 1 ) - accele_y_bias) * (5.0 / 1024.0 * 1.0) ;
accele_z[0] = (ADC_read( 2 ) - 502.5 ) * (5.0 / 1024.0 * 1.0) ;
jyro_x = (ADC_read( 3 ) - jyro_x_bias) * (5.0 / 1024.0 * 0.0067) ;
jyro_y = (ADC_read( 4 ) - jyro_y_bias) * (5.0 / 1024.0 * 0.0067) ;
accele_x[0] = accele_x[1] * 0.9 + accele_x[0] * 0.1;
accele_y[0] = accele_y[1] * 0.9 + accele_y[0] * 0.1;
accele_z[0] = accele_z[1] * 0.9 + accele_z[0] * 0.1;
theta_x = atan(accele_x[0] / sqrt(accele_y[0] * accele_y[0] + accele_z[0] * accele_z[0])) * (180.0 / 3.141592654 );
theta_y = atan(accele_y[0] / sqrt(accele_x[0] * accele_x[0] + accele_z[0] * accele_z[0])) * (180.0 / 3.141592654 );
roll += (jyro_x * (0.000128 * (double)TMR0) ) - ( (2.0 * 3.141592654 * 0.198 ) * roll * (0.000128 * (double)TMR0) ) + ( (2.0 * 3.141592654 * 0.198 ) * theta_x * (0.000128 * (double)TMR0) );
pitch += (jyro_y * (0.000128 * (double)TMR0) ) - ( (2.0 * 3.141592654 * 0.198 ) * pitch * (0.000128 * (double)TMR0) ) + ( (2.0 * 3.141592654 * 0.198 ) * theta_y * (0.000128 * (double)TMR0) );
if(-0.1 < roll && roll < 0.1)
roll = 0.0;
if(-0.1 < pitch && pitch < 0.1)
pitch = 0.0;
#line 92 "C:/Users/i121326/Documents/workspace/robot/jyro_accelerometer/angle_v9/angle_v9.c"
OutPut(-pitch + roll * 0.5, -pitch - roll * 0.5);
}
}
void SetUp()
{
OSCCON = 0x70;
OPTION_REG = 0x07;
ANSELA = 0x2F;
ANSELB = 0x00;
ANSELD = 0x00;
ANSELE = 0x00;
TRISA = 0x2F;
TRISB = 0x20;
TRISC = 0x00;
TRISD = 0x00;
TRISE = 0x00;
PORTA = 0x00;
PORTB = 0x00;
PORTC = 0x00;
PORTD = 0x00;
PORTE = 0x00;
ADC_Init();
UART1_Init(9600);
Soft_UART_Init(&PORTB, 6, 4, 9600, 0);
Delay_ms(10);
}
void OutPut(double right, double left)
{
int tmp;
UART1_Write(0);
UART1_Write((right >= 0.0) ? 0 : 1);
tmp = (int)(abs(right) * 10.0);
UART1_Write(tmp);
Soft_UART_Write(0);
Soft_UART_Write((left >= 0.0) ? 0 : 1);
tmp = (int)(abs(left) * 10.0);
Soft_UART_Write(tmp);
}
void Debug(double roll, double pitch)
{
int tmp;
Soft_UART_Write('R');
Soft_UART_Write(':');
Soft_UART_Write((roll >= 0.0) ? '+' : '-');
tmp = (roll >= 0.0) ? roll * 10.0 : -roll * 10.0;
Soft_UART_Write(Dec2Ascii((tmp % 1000 - tmp % 100) / 100));
Soft_UART_Write(Dec2Ascii((tmp % 100 - tmp % 10) / 10));
Soft_UART_Write('.');
Soft_UART_Write(Dec2Ascii(tmp % 10));
Soft_UART_Write(' ');
Soft_UART_Write('P');
Soft_UART_Write(':');
Soft_UART_Write((pitch >= 0.0) ? '+' : '-');
tmp = (pitch >= 0.0) ? pitch * 10.0 : -pitch * 10.0;
Soft_UART_Write(Dec2Ascii((tmp % 1000 - tmp % 100) / 100));
Soft_UART_Write(Dec2Ascii((tmp % 100 - tmp % 10) / 10));
Soft_UART_Write('.');
Soft_UART_Write(Dec2Ascii(tmp % 10));
Soft_UART_Write('\n');
}
void AcceleCheck(double accele_x, double accele_y, double accele_z)
{
int tmp;
tmp = (int)accele_x;
Soft_UART_Write('X');
Soft_UART_Write(':');
Soft_UART_Write(Dec2Ascii((tmp % 10000 - tmp % 1000) / 1000));
Soft_UART_Write(Dec2Ascii((tmp % 1000 - tmp % 100) / 100));
Soft_UART_Write(Dec2Ascii((tmp % 100 - tmp % 10) / 10));
Soft_UART_Write(Dec2Ascii(tmp % 10));
Soft_UART_Write(' ');
tmp = (int)accele_y;
Soft_UART_Write('Y');
Soft_UART_Write(':');
Soft_UART_Write(Dec2Ascii((tmp % 10000 - tmp % 1000) / 1000));
Soft_UART_Write(Dec2Ascii((tmp % 1000 - tmp % 100) / 100));
Soft_UART_Write(Dec2Ascii((tmp % 100 - tmp % 10) / 10));
Soft_UART_Write(Dec2Ascii(tmp % 10));
Soft_UART_Write(' ');
tmp = (int)accele_z;
Soft_UART_Write('Z');
Soft_UART_Write(':');
Soft_UART_Write(Dec2Ascii((tmp % 10000 - tmp % 1000) / 1000));
Soft_UART_Write(Dec2Ascii((tmp % 1000 - tmp % 100) / 100));
Soft_UART_Write(Dec2Ascii((tmp % 100 - tmp % 10) / 10));
Soft_UART_Write(Dec2Ascii(tmp % 10));
Soft_UART_Write('\n');
}
char Dec2Ascii(char dec)
{
switch(dec){
case 0: return '0';
case 1: return '1';
case 2: return '2';
case 3: return '3';
case 4: return '4';
case 5: return '5';
case 6: return '6';
case 7: return '7';
case 8: return '8';
case 9: return '9';
default: return '*';
}
}
| [
"simu3.developer@gmail.com"
] | simu3.developer@gmail.com |
489590dd5905af24ccb90e644c47fd8652e140d0 | 3bbdb849378fcd4eedaedcb545b474b7c4703423 | /core/src/mapcss/StyleProvider.cpp | d86bd92c97282e3b6058633de33de84af8475719 | [
"Apache-2.0"
] | permissive | TechnoBotz/utymap | 9104438d5b53b78ed7dd948528370e86fba8b6e3 | 0f04913f179e9f16ff751cc18011eb0a12f62bde | refs/heads/master | 2020-05-23T08:07:48.511998 | 2016-09-30T21:46:48 | 2016-09-30T21:46:48 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,232 | cpp | #include "entities/ElementVisitor.hpp"
#include "entities/Node.hpp"
#include "entities/Way.hpp"
#include "entities/Area.hpp"
#include "entities/Relation.hpp"
#include "mapcss/Style.hpp"
#include "mapcss/StyleProvider.hpp"
#include "utils/CoreUtils.hpp"
#include "utils/GradientUtils.hpp"
#include <functional>
#include <mutex>
using namespace utymap::entities;
using namespace utymap::index;
using namespace utymap::mapcss;
namespace {
const std::string DefaultTextureName = "";
/// Contains operation types supported by mapcss parser.
enum class OpType { Exists, Equals, NotEquals, Less, Greater };
struct ConditionType final
{
uint32_t key;
uint32_t value;
OpType type;
};
struct Filter final
{
std::vector<ConditionType> conditions;
std::unordered_map<uint32_t, std::unique_ptr<const StyleDeclaration>> declarations;
Filter() = default;
Filter(const Filter& other) = delete;
Filter(Filter&& other) :
conditions(std::move(other.conditions)),
declarations(std::move(other.declarations))
{
}
};
/// Key: level of details, value: filters for specific element type.
typedef std::unordered_map<int, std::vector<Filter>> FilterMap;
struct FilterCollection final
{
FilterMap nodes;
FilterMap ways;
FilterMap areas;
FilterMap relations;
FilterMap canvases;
};
class StyleBuilder final : public ElementVisitor
{
typedef std::vector<Tag>::const_iterator TagIterator;
public:
StyleBuilder(std::vector<Tag> tags, StringTable& stringTable,
const FilterCollection& filters, int levelOfDetails, bool onlyCheck = false) :
style(tags, stringTable),
filters_(filters),
levelOfDetails_(levelOfDetails),
onlyCheck_(onlyCheck),
canBuild_(false),
stringTable_(stringTable)
{
}
void visitNode(const Node& node) override { checkOrBuild(node.tags, filters_.nodes); }
void visitWay(const Way& way) override { checkOrBuild(way.tags, filters_.ways); }
void visitArea(const Area& area) override { checkOrBuild(area.tags, filters_.areas); }
void visitRelation(const Relation& relation) override { checkOrBuild(relation.tags, filters_.relations); }
bool canBuild() const { return canBuild_; }
Style style;
private:
void checkOrBuild(const std::vector<Tag>& tags, const FilterMap& filters)
{
if (onlyCheck_)
check(tags, filters);
else
build(tags, filters);
}
/// checks tag's value assuming that the key is already checked.
bool matchTag(const Tag& tag, const ConditionType& condition)
{
switch (condition.type) {
case OpType::Exists:
return true;
case OpType::Equals:
return tag.value == condition.value;
case OpType::NotEquals:
return tag.value != condition.value;
case OpType::Less:
return compareDoubles(tag.value, condition.value, std::less<double>());
case OpType::Greater:
return compareDoubles(tag.value, condition.value, std::greater<double>());
}
}
/// Compares two raw string values using double conversion.
template<typename Func>
bool compareDoubles(std::uint32_t left, std::uint32_t right, Func binaryOp)
{
double leftValue = utymap::utils::parseDouble(stringTable_.getString(left));
double rightValue = utymap::utils::parseDouble(stringTable_.getString(right));
return binaryOp(leftValue, rightValue);
}
/// Tries to find tag which satisfy condition using binary search.
bool matchTags(TagIterator begin, TagIterator end, const ConditionType& condition)
{
while (begin < end) {
const TagIterator middle = begin + (std::distance(begin, end) / 2);
if (middle->key == condition.key)
return matchTag(*middle, condition);
else if (middle->key > condition.key)
end = middle;
else
begin = middle + 1;
}
return false;
}
/// Builds style object. More expensive to call than check.
void build(const std::vector<Tag>& tags, const FilterMap& filters)
{
FilterMap::const_iterator iter = filters.find(levelOfDetails_);
if (iter != filters.end()) {
for (const Filter& filter : iter->second) {
bool isMatched = true;
for (auto it = filter.conditions.cbegin(); it != filter.conditions.cend() && isMatched; ++it) {
isMatched &= matchTags(tags.cbegin(), tags.cend(), *it);
}
// merge declarations to style
if (isMatched) {
canBuild_ = true;
for (const auto& d : filter.declarations) {
style.put(*d.second);
}
}
}
}
}
/// Just checks whether style can be created without constructing actual style.
void check(const std::vector<Tag>& tags, const FilterMap& filters)
{
FilterMap::const_iterator iter = filters.find(levelOfDetails_);
if (iter != filters.end()) {
for (const Filter& filter : iter->second) {
bool isMatched = true;
for (auto it = filter.conditions.cbegin(); it != filter.conditions.cend() && isMatched; ++it) {
isMatched &= matchTags(tags.cbegin(), tags.cend(), *it);
}
if (isMatched) {
canBuild_ = true;
return;
}
}
}
}
const FilterCollection &filters_;
int levelOfDetails_;
bool onlyCheck_;
bool canBuild_;
StringTable& stringTable_;
};
}
/// Converts mapcss stylesheet to index optimized representation to speed search query up.
class StyleProvider::StyleProviderImpl
{
public:
FilterCollection filters;
StringTable& stringTable;
std::unordered_map<std::string, std::unique_ptr<const ColorGradient>> gradients;
std::unordered_map<std::string, std::unique_ptr<const TextureAtlas>> textures;
StyleProviderImpl(const StyleSheet& stylesheet,
StringTable& stringTable) :
filters(),
stringTable(stringTable),
gradients(),
textures()
{
filters.nodes.reserve(24);
filters.ways.reserve(24);
filters.areas.reserve(24);
filters.relations.reserve(24);
filters.canvases.reserve(24);
for (const Rule& rule : stylesheet.rules) {
for (const Selector& selector : rule.selectors) {
for (const std::string& name : selector.names) {
FilterMap* filtersPtr = nullptr;
if (name == "node") filtersPtr = &filters.nodes;
else if (name == "way") filtersPtr = &filters.ways;
else if (name == "area") filtersPtr = &filters.areas;
else if (name == "relation") filtersPtr = &filters.relations;
else if (name == "canvas") filtersPtr = &filters.canvases;
else
throw std::domain_error("Unexpected selector name:" + name);
Filter filter;
filter.conditions.reserve(selector.conditions.size());
for (const Condition& condition : selector.conditions) {
ConditionType c;
if (condition.operation == "") c.type = OpType::Exists;
else if (condition.operation == "=") c.type = OpType::Equals;
else if (condition.operation == "!=") c.type = OpType::NotEquals;
else if (condition.operation == "<") c.type = OpType::Less;
else if (condition.operation == ">") c.type = OpType::Greater;
else
throw std::domain_error("Unexpected condition operation:" + condition.operation);
c.key = stringTable.getId(condition.key);
c.value = stringTable.getId(condition.value);
filter.conditions.push_back(c);
}
filter.declarations.reserve(rule.declarations.size());
for (auto i = 0; i < rule.declarations.size(); ++i) {
Declaration declaration = rule.declarations[i];
uint32_t key = stringTable.getId(declaration.key);
if (utymap::utils::GradientUtils::isGradient(declaration.value))
addGradient(declaration.value);
filter.declarations[key] = utymap::utils::make_unique<const StyleDeclaration>(key, declaration.value);
}
std::sort(filter.conditions.begin(), filter.conditions.end(),
[](const ConditionType& c1, const ConditionType& c2) { return c1.key > c2.key; });
for (int i = selector.zoom.start; i <= selector.zoom.end; ++i) {
(*filtersPtr)[i].push_back(std::move(filter));
}
}
}
}
textures.emplace(DefaultTextureName, utymap::utils::make_unique<const TextureAtlas>());
for (const auto& texture: stylesheet.textures) {
textures.emplace(texture.name(), utymap::utils::make_unique<const TextureAtlas>(texture));
}
}
const ColorGradient& getGradient(const std::string& key)
{
auto gradientPair = gradients.find(key);
if (gradientPair == gradients.end()) {
auto gradient = utymap::utils::GradientUtils::parseGradient(key);
if (gradient->empty())
throw MapCssException("Invalid gradient: " + key);
std::lock_guard<std::mutex> lock(lock_);
gradients.emplace(key, std::move(gradient));
gradientPair = gradients.find(key);
}
return *gradientPair->second;
}
const TextureGroup& getTexture(const std::string& texture, const std::string& key) const
{
auto texturePair = textures.find(texture);
if (texturePair == textures.end()) {
texturePair = textures.find(DefaultTextureName);
}
return texturePair->second->get(key);
}
private:
void addGradient(const std::string& key)
{
if (gradients.find(key) == gradients.end()) {
auto gradient = utymap::utils::GradientUtils::parseGradient(key);
if (!gradient->empty())
gradients.emplace(key, std::move(gradient));
}
}
std::mutex lock_;
};
StyleProvider::StyleProvider(const StyleSheet& stylesheet, StringTable& stringTable) :
pimpl_(utymap::utils::make_unique<StyleProviderImpl>(stylesheet, stringTable))
{
}
StyleProvider::~StyleProvider()
{
}
StyleProvider::StyleProvider(StyleProvider&& other) : pimpl_(std::move(other.pimpl_))
{
}
bool StyleProvider::hasStyle(const utymap::entities::Element& element, int levelOfDetails) const
{
StyleBuilder builder(element.tags, pimpl_->stringTable, pimpl_->filters, levelOfDetails, true);
element.accept(builder);
return builder.canBuild();
}
Style StyleProvider::forElement(const Element& element, int levelOfDetails) const
{
StyleBuilder builder(element.tags, pimpl_->stringTable, pimpl_->filters, levelOfDetails);
element.accept(builder);
return std::move(builder.style);
}
Style StyleProvider::forCanvas(int levelOfDetails) const
{
Style style({}, pimpl_->stringTable);
for (const auto &filter : pimpl_->filters.canvases[levelOfDetails]) {
for (const auto &declaration : filter.declarations) {
style.put(*declaration.second);
}
}
return std::move(style);
}
const ColorGradient& StyleProvider::getGradient(const std::string& key) const
{
return pimpl_->getGradient(key);
}
const TextureGroup& StyleProvider::getTexture(const std::string& texture, const std::string& key) const
{
return pimpl_->getTexture(texture, key);
}
| [
"ilya.builuk@gmail.com"
] | ilya.builuk@gmail.com |
2b61608f4c03a1267b89654ce213f4516c58f451 | 8c537e968a6fe71a1fda0dbe70fe9404a6b7d227 | /SurviveGameNewNew/SurviveGameNewNew/MyWidgets/MySaveWidget.cpp | f873566b37e7ffe503e6ce74b1f675fec2fa0572 | [] | no_license | jkjkil4/SurviveGameNewNew | 51cded801b4ffd71ee3fa01fc1308f3c3fbac7cf | 6c00c47a19073cc8508ede27f0d9dfd366969a16 | refs/heads/master | 2021-02-09T20:17:08.739270 | 2020-05-04T06:51:37 | 2020-05-04T06:51:37 | 244,321,360 | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 1,046 | cpp | #include "MySaveWidget.h"
MySaveWidget::MySaveWidget(MyEngine* e, int w, int h, MySave* save, LPD3DXFONT g_pFont, LPD3DXFONT g_pFontSmall, MyWidget* parent)
: MyWidget(e, w, h, nullptr, parent),
save(save), g_pFont(g_pFont), g_pFontSmall(g_pFontSmall) {}
inline void MySaveWidget::_onRender(LPD3DXSPRITE g_pSprite, int renderX, int renderY) {
//»æÖƱ³¾°
D3DCOLOR bgColor = color;
if (shownSave) {
if (save == *shownSave)
bgColor = selColor;
}
e->drawRect(renderX, renderY, w, h, bgColor, bgColor, bgColor, bgColor);
//»æÖÆÎÄ×Ö
if (save->info) {
MySave::Info* info = save->info;
RECT allowedRect = rect(renderX + 3, renderY + 3, w - 6, h - 8);
g_pFont->DrawText(g_pSprite, info->name.c_str(), -1, &allowedRect, DT_LEFT | DT_TOP, textColor);
g_pFontSmall->DrawText(g_pSprite, info->fileName.c_str(), -1, &allowedRect, DT_LEFT | DT_BOTTOM, textColor2);
}
}
inline void MySaveWidget::_mouseEvent(MyMouseEvent ev) {
if (ev.type == Press && ev.mouse == VK_LBUTTON)
if (shownSave)
*shownSave = save;
}
| [
"52841865+jkjkil4@users.noreply.github.com"
] | 52841865+jkjkil4@users.noreply.github.com |
5cf524f191c7e86ffb2de7ee60de39a936558423 | f3d628043cf15afe9c7074035322f850dfbd836d | /codeforces/1468/n/n.cpp | 78ef0d660d609cdb2d65a8c7a794968ca0243329 | [
"MIT"
] | permissive | Shahraaz/CP_S5 | 6f812c37700400ea8b5ea07f3eff8dcf21a8f468 | 2cfb5467841d660c1e47cb8338ea692f10ca6e60 | refs/heads/master | 2021-07-26T13:19:34.205574 | 2021-06-30T07:34:30 | 2021-06-30T07:34:30 | 197,087,890 | 5 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,173 | cpp | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "/debug.h"
#else
#define db(...)
#endif
#define all(v) v.begin(), v.end()
#define pb push_back
using ll = long long;
const int NAX = 2e5 + 5, MOD = 1000000007;
void solveCase()
{
vector<int> c(3), a(5);
for (auto &x : c)
cin >> x;
for (auto &x : a)
cin >> x;
c[0] -= a[0];
c[1] -= a[1];
c[2] -= a[2];
a[0] = a[1] = a[2] = 0;
for (auto &x : c)
{
if (x < 0)
{
cout << "NO\n";
return;
}
}
int temp = min(a[3], c[0]);
c[0] -= temp;
a[3] -= temp;
for (auto &x : c)
{
if (x < 0)
{
cout << "NO\n";
return;
}
}
temp = min(a[4], c[1]);
c[1] -= temp;
a[4] -= temp;
c[2] -= a[3] + a[4];
for (auto &x : c)
{
if (x < 0)
{
cout << "NO\n";
return;
}
}
cout << "YES\n";
}
int32_t main()
{
#ifndef LOCAL
ios_base::sync_with_stdio(0);
cin.tie(0);
#endif
int t = 1;
cin >> t;
for (int i = 1; i <= t; ++i)
solveCase();
return 0;
} | [
"shahraazhussain@gmail.com"
] | shahraazhussain@gmail.com |
c828fead699b487f2af2d9c30145615cfaceafd3 | 4f8e69f9302bfc3c4b9484e174b5cc7de278fce2 | /sample/sp/code/main.cpp | 67ffb3e767548b7b0da466cb29b6ad42f9332adc | [
"MIT"
] | permissive | 245nishiko/simplesp | 1d461a72b3be3c650600cea6bd5415a818698475 | 6a71022dbb9a304e5a68d60885a04906dc78913a | refs/heads/master | 2023-02-19T01:47:37.486233 | 2020-12-06T12:50:58 | 2020-12-06T12:50:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,024 | cpp | #define SP_USE_DEBUG 1
#include "simplesp.h"
using namespace sp;
int main() {
//--------------------------------------------------------------------------------
// zip like encode & decode
//--------------------------------------------------------------------------------
{
Mem1<int> src;
{
int _src[] = { 0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 4, 3, 3, 0, 2, 1 };
src.push(_src, sizeof(_src) / sizeof(int));
print("src ", src);
}
const int maxv = max(src) + 1;
{
const Mem1<Mem1<Byte>> table = hmMakeTableFromCnts(getCodeCnts(src, maxv));
const Mem1<Byte> enc = hmEncode(table, src);
print("enc ", enc);
const Mem1<int> dec = hmDecode(table, enc);
print("dec", dec);
}
{
const Mem1<int> encA = lzssEncode(src, maxv, 63, 3, 15);
const Mem1<int> cnts = lzssCnts(encA, maxv);
const Mem1<Byte> encB = zlEncode(hmMakeTableFromCnts(cnts), encA, maxv, 6, 4);
const Mem1<int> decB = zlDecode(hmMakeTableFromCnts(cnts), encB, maxv, 6, 4);
const Mem1<int> decA = lzssDecode(decB, 5);
print("encA", encA);
print("encB", encB);
print("decB", decB);
print("decA", decA);
}
}
//--------------------------------------------------------------------------------
// base 64 encode & decode
//--------------------------------------------------------------------------------
{
Mem1<Byte> src;
{
Byte _src[] = { 0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 4, 3, 3, 0, 2, 1 };
src.push(_src, sizeof(_src) / sizeof(Byte));
print("src ", src);
}
{
const Mem1<char> enc = base64Encode(src.ptr, src.size());
const Mem1<Byte> dec = base64Decode(enc.ptr);
printf("enc %s\n", enc.ptr);
print("dec", dec);
}
}
return 0;
} | [
"sanko.shoko@gmail.com"
] | sanko.shoko@gmail.com |
d4ab18346641f1758fdd9daa5ab0ddfd39bbf32d | 43101e21b88d47e8fd4a13c8f0a55e599495dbf6 | /resize/mainwindow.h | f684051d1bf7eae1b8580ca0d01e87369e26bb2e | [] | no_license | mbjapzon/resize | 1cfbf03e88cf0b836d59696a158511aef4f3e19f | 3969a22d5661c024dd63616a03bd5d7cfca9b65d | refs/heads/master | 2020-04-04T22:25:13.530894 | 2018-11-06T21:20:35 | 2018-11-06T21:20:35 | 156,323,573 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 466 | h | #ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include "sequenceWidget.h"
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = nullptr);
~MainWindow();
private slots:
void on_pushButton_clicked();
private:
Ui::MainWindow *ui;
QGraphicsScene * m_scene;
SequenceWidget * m_sequence;
};
#endif // MAINWINDOW_H
| [
"noreply@github.com"
] | mbjapzon.noreply@github.com |
55ad3454d3e9a8490c826d0a29921f60be8833d1 | 3229832db88314105d7231bd0aef539bc74a98b8 | /src/util.cc | 1a3235a2cd75caa8e48d97b8cb9f2c8d3f426da3 | [
"MIT"
] | permissive | looksgood/spdylay | b2e20b461f21b1150f582a5f64298482746948cf | fc0cfc7faf840af5c99f52e68ea3d8343aab9101 | refs/heads/master | 2021-01-16T18:08:07.234335 | 2013-03-01T12:01:45 | 2013-03-01T12:01:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,582 | cc | /*
* Spdylay - SPDY Library
*
* Copyright (c) 2012 Tatsuhiro Tsujikawa
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "util.h"
#include <time.h>
#include <cstdio>
#include <cstring>
namespace spdylay {
namespace util {
const char DEFAULT_STRIP_CHARSET[] = "\r\n\t ";
bool isAlpha(const char c)
{
return ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z');
}
bool isDigit(const char c)
{
return '0' <= c && c <= '9';
}
bool isHexDigit(const char c)
{
return isDigit(c) || ('A' <= c && c <= 'F') || ('a' <= c && c <= 'f');
}
bool inRFC3986UnreservedChars(const char c)
{
static const char unreserved[] = { '-', '.', '_', '~' };
return isAlpha(c) || isDigit(c) ||
std::find(&unreserved[0], &unreserved[4], c) != &unreserved[4];
}
std::string percentEncode(const unsigned char* target, size_t len)
{
std::string dest;
for(size_t i = 0; i < len; ++i) {
if(inRFC3986UnreservedChars(target[i])) {
dest += target[i];
} else {
char temp[4];
snprintf(temp, sizeof(temp), "%%%02X", target[i]);
dest.append(temp);
//dest.append(fmt("%%%02X", target[i]));
}
}
return dest;
}
std::string percentEncode(const std::string& target)
{
return percentEncode(reinterpret_cast<const unsigned char*>(target.c_str()),
target.size());
}
std::string percentDecode
(std::string::const_iterator first, std::string::const_iterator last)
{
std::string result;
for(; first != last; ++first) {
if(*first == '%') {
if(first+1 != last && first+2 != last &&
isHexDigit(*(first+1)) && isHexDigit(*(first+2))) {
std::string numstr(first+1, first+3);
result += strtol(numstr.c_str(), 0, 16);
first += 2;
} else {
result += *first;
}
} else {
result += *first;
}
}
return result;
}
std::string http_date(time_t t)
{
char buf[32];
tm* tms = gmtime(&t); // returned struct is statically allocated.
size_t r = strftime(buf, sizeof(buf), "%a, %d %b %Y %H:%M:%S GMT", tms);
return std::string(&buf[0], &buf[r]);
}
time_t parse_http_date(const std::string& s)
{
tm tm;
memset(&tm, 0, sizeof(tm));
char* r = strptime(s.c_str(), "%a, %d %b %Y %H:%M:%S GMT", &tm);
if(r == 0) {
return 0;
}
return timegm(&tm);
}
bool startsWith(const std::string& a, const std::string& b)
{
return startsWith(a.begin(), a.end(), b.begin(), b.end());
}
bool istartsWith(const std::string& a, const std::string& b)
{
return istartsWith(a.begin(), a.end(), b.begin(), b.end());
}
namespace {
void streq_advance(const char **ap, const char **bp)
{
for(; **ap && **bp && lowcase(**ap) == lowcase(**bp); ++*ap, ++*bp);
}
} // namespace
bool istartsWith(const char *a, const char* b)
{
if(!a || !b) {
return false;
}
streq_advance(&a, &b);
return !*b;
}
bool endsWith(const std::string& a, const std::string& b)
{
return endsWith(a.begin(), a.end(), b.begin(), b.end());
}
bool strieq(const char *a, const char *b)
{
if(!a || !b) {
return false;
}
for(; *a && *b && lowcase(*a) == lowcase(*b); ++a, ++b);
return !*a && !*b;
}
bool strifind(const char *a, const char *b)
{
if(!a || !b) {
return false;
}
for(size_t i = 0; a[i]; ++i) {
const char *ap = &a[i], *bp = b;
for(; *ap && *bp && lowcase(*ap) == lowcase(*bp); ++ap, ++bp);
if(!*bp) {
return true;
}
}
return false;
}
char upcase(char c)
{
if('a' <= c && c <= 'z') {
return c-'a'+'A';
} else {
return c;
}
}
} // namespace util
} // namespace spdylay
| [
"tatsuhiro.t@gmail.com"
] | tatsuhiro.t@gmail.com |
46bc1cae32ad8b07586d87d7fa4fe29b10055092 | 50dc1bb36d583884ea7a198d3b605247b54d9dea | /skinchanger.cc/SDK/globals/globals.cpp | 0f411e6a50851d8982db67c8c8f1fd218ab97356 | [] | no_license | n30np14gu3/skinchanger.cc | c5845a37e921b4722d71cacd6713fc27125ea46c | 5e05817ac945de6cb393497084b47a4200750b32 | refs/heads/master | 2023-01-23T23:14:36.444829 | 2020-11-25T16:03:15 | 2020-11-25T16:03:15 | 236,482,706 | 5 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 187 | cpp | #include "globals.h"
#include "../crypto/XorStr.h"
namespace globals
{
string hwid;
int last_update = 1579392001;
int code;
void initGlobals()
{
last_update = 0;
code = 0;
}
} | [
"darknetsoft@yandex.ru"
] | darknetsoft@yandex.ru |
c6df0103c8acc587b217e66ea76073c3e8ab367e | e246116503e60e7e7538f0875fa4829e468ffa49 | /shaderLoader.cpp | acab141d6d7e9f00ed4d71c3e8d47dcd297cd45e | [] | no_license | viktorhellqvist/voxel-test | e1418b631cb4e2fed393763a0db35c3161fdd637 | 029b52c9af435a5af801441dab9d1d15770c5cb1 | refs/heads/main | 2023-08-29T10:56:47.369785 | 2021-10-21T20:45:04 | 2021-10-21T20:45:04 | 418,400,105 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,032 | cpp | #include "shaderLoader.h"
#include <iostream>
Shader::Shader(const char* vertexPath, const char* fragmentPath)
{
// Read the Vertex Shader code from the file
std::string VertexShaderCode;
std::ifstream VertexShaderStream(vertexPath, std::ios::in);
if (VertexShaderStream.is_open()) {
std::stringstream sstr;
sstr << VertexShaderStream.rdbuf();
VertexShaderStream.close();
VertexShaderCode = sstr.str();
}
else {
std::cout << "ERROR: Vertex shader file could not be read" << std::endl;
}
// Read the Fragment Shader code from the file
std::string FragmentShaderCode;
std::ifstream FragmentShaderStream(fragmentPath, std::ios::in);
if (FragmentShaderStream.is_open()) {
std::stringstream sstr;
sstr << FragmentShaderStream.rdbuf();
FragmentShaderCode = sstr.str();
FragmentShaderStream.close();
}
else {
std::cout << "ERROR: Vertex shader file could not be read" << std::endl;
}
const char* vertexSrc = VertexShaderCode.c_str();
const char* fragmentSrc = FragmentShaderCode.c_str();
Compile(vertexSrc, fragmentSrc);
}
Shader& Shader::use()
{
glUseProgram(this->ID);
return *this;
}
void Shader::Compile(const char* vertexSource, const char* fragmentSource)
{
unsigned int sVertex, sFragment, gShader;
// vertex Shader
sVertex = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(sVertex, 1, &vertexSource, NULL);
glCompileShader(sVertex);
checkCompileErrors(sVertex, "VERTEX");
// fragment Shader
sFragment = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(sFragment, 1, &fragmentSource, NULL);
glCompileShader(sFragment);
checkCompileErrors(sFragment, "FRAGMENT");
// shader program
this->ID = glCreateProgram();
glAttachShader(this->ID, sVertex);
glAttachShader(this->ID, sFragment);
glLinkProgram(this->ID);
checkCompileErrors(this->ID, "PROGRAM");
// delete the shaders as they're linked into our program now and no longer necessary
glDeleteShader(sVertex);
glDeleteShader(sFragment);
}
void Shader::checkCompileErrors(unsigned int object, std::string type)
{
int success;
char infoLog[1024];
if (type != "PROGRAM") {
glGetShaderiv(object, GL_COMPILE_STATUS, &success);
if (!success) {
glGetShaderInfoLog(object, 1024, NULL, infoLog);
std::cout << "| ERROR::SHADER: Compile-time error: Type: " << type << "\n"
<< infoLog << "\n -- --------------------------------------------------- -- "
<< std::endl;
}
}
else {
glGetProgramiv(object, GL_LINK_STATUS, &success);
if (!success) {
glGetProgramInfoLog(object, 1024, NULL, infoLog);
std::cout << "| ERROR::Shader: Link-time error: Type: " << type << "\n"
<< infoLog << "\n -- --------------------------------------------------- -- "
<< std::endl;
}
}
} | [
"vikhe931@student.liu.se"
] | vikhe931@student.liu.se |
3a4d16b19bab19704992fd4307757eda82a51a96 | 7de3b24a478651e60f851276f31d12644ff53c47 | /projects/smart_home/src/thread.cpp | c63c1b7ae776362c7602e0d9bd640b1685403d73 | [] | no_license | maoral1810/alankri | 01203e3a6440d99f6b6f55008b56adb56bc6a319 | 396fc99d8531acd285349993e08f738525cdeed7 | refs/heads/master | 2021-07-17T05:47:14.310537 | 2020-10-13T18:14:05 | 2020-10-13T18:14:05 | 218,999,329 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,830 | cpp | #include <pthread.h> // pthread create
#include <iostream> // runtime_error
#include <cassert> // assert
#include <cerrno>
#include "thread.hpp"
#include "runnable.hpp"
#include "thread_exceptions.hpp"
namespace smart_home {
static void ThreadCreateErrors(int a_status);
static bool TimeJoinError(int a_status);
Thread::Thread(Runnable* a_runFunc)
: m_runFunc(a_runFunc)
, m_isJoinable(true)
{
int threadStatus = pthread_create(&m_id, 0, CallBackFunction, this);
if(threadStatus)
{
ThreadCreateErrors(threadStatus);
}
}
Thread::~Thread()
{
if(m_isJoinable)
{
//this->Join();
assert(!"thread was not join or detach");
}
}
void Thread::Join()
{
if(m_isJoinable)
{
int Status = pthread_join(m_id, 0);
if(Status)
{
switch (Status)
{
case EDEADLK:
throw(std::runtime_error("A deadlock was detected"));
break;
default: assert(!"non doucument pthread join error");
break;
}
}
else
{
m_isJoinable = false;
}
}
}
bool Thread::TimeJoin(const timespec& timeUntilShutDown)
{
bool status = false;
if (!m_isJoinable)
{
int retval = pthread_timedjoin_np(m_id, 0, &timeUntilShutDown);
status = TimeJoinError(retval);
if(status) {
m_isJoinable = false;
}
}
return status;
}
void Thread::Cancel()
{
int retval = pthread_cancel(m_id);
switch (retval)
{
case ESRCH:
assert(!"No thread with the ID thread could be found");
break;
default: /* m_isJoinable = true; */break;
}
}
void Thread::Exit()
{
//pthread_exit()
}
void Thread::Detach()
{
if(m_isJoinable) {
int detachStatus = pthread_detach(m_id);
if(detachStatus)
{
switch (detachStatus)
{
case ESRCH:
assert(!"No thread with the ID thread could be found");
break;
case EINVAL:
assert(!"thread is not a joinable thread");
break;
default: assert(!"non doucument pthread join error");
break;
}
}
else {
m_isJoinable = false;
}
}
}
void* Thread::CallBackFunction(void* a_object)
{
assert(a_object);
Thread* thread = reinterpret_cast<Thread*>(a_object);
thread->DoWork();
return 0;
}
void Thread::DoWork()
{
try {
m_runFunc->Run();
}
catch(std::exception const& x)
{
std::cout << std::endl;
std::cerr << x.what();
assert(!"Rum thread fail");
} catch(...) {
assert(false);
}
}
// ---------------------- error functions ---------------------
static void ThreadCreateErrors(int a_status)
{
switch(a_status) {
case EPERM:
throw ThreadCreateEPERM();
break;
case EAGAIN:
throw ThreadCreateEAGAIN();
break;
default:
assert(!"failed in pthread create");
break;
}
}
static bool TimeJoinError(int a_status)
{
switch (a_status)
{
case ETIMEDOUT:
//The call timed out before thread terminated.
return false;
case EDEADLK:
throw ThreadTimeJoinEDEADLK();
break;
case EINVAL:
assert(!"Another thread is already waiting to join with this thread");
break;
case ESRCH:
assert(!"No thread with the ID thread could be found");
break;
default: break;
}
return true;
}
}// namespace smart_home
| [
"maoral1810@gmail.com"
] | maoral1810@gmail.com |
04232a303576eff82a2aac0070c589e24ae811e9 | aee6532e12c540c4debef475dd54c923519df8fe | /test/kmpdemo.cpp | c7ddd5af56eb004db51c04cc0a97957bad386ca0 | [
"MIT"
] | permissive | huazhang2/Algorithm | b64b958d8f22b7428e06078ef2d496a3c913540c | 63627d84ca8a648049340f0fdc4649c134e0dd3d | refs/heads/master | 2020-03-19T13:17:58.984609 | 2018-06-08T05:25:50 | 2018-06-08T05:42:36 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 679 | cpp | #include <iostream>
#include "mybasic.h"
#include "mykmp.h"
int main(int argc, char *argv[])
{
const char *str = "BBCABCDABABCDABCDABDET";
const char *pattern = "BCDABDE";
int ptLen = strlen(pattern);
int kmpIndex = -1;
cout << "basic kmp: " << endl;
cout << "str = " << str << endl;
cout << "pattern = " << pattern << endl;
kmpIndex = subStrSearch(str, pattern);
cout << "Index = " << kmpIndex << endl;
cout << "\noptimized kmp: " << endl;
cout << "str = " << str << endl;
cout << "pattern = " << pattern << endl;
kmpIndex = subStrSearchOptimized(str, pattern);
cout << "Index = " << kmpIndex << endl;
return 0;
}
| [
"xiangp126@126.com"
] | xiangp126@126.com |
0a96bbc728aa6e0aeded71f72888828f85d5b780 | c9b454b7d95cb09c21fe133b00a8ae0daf99dcc8 | /MemoryDrinker.cpp | 345d75d9fcf0f78635419b6b82c43063926c7384 | [] | no_license | thiyagu86/sample_projects | 1d472aa0a8c4dcb174be42f71efc928e8b90c3d3 | d5c2c93d96d0d11e6c2fe3c0a2c1ab611f0d94ed | refs/heads/master | 2021-07-14T14:01:09.568435 | 2020-08-25T15:10:54 | 2020-08-25T15:10:54 | 199,885,184 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,070 | cpp | /*Code Snipped for Simulating Different Memory Loads*/
#include <iostream>
#include <sys/sysinfo.h>
int phys_mem_avail(void)
{
struct sysinfo info;
int err = sysinfo(&info);
if (-1 != err)
{
return (100 - ((info.freeram * 100)/info.totalram));
}
else
{
return -1;
}
}
int main(int argc, char *argv[])
{
int iMem = 0;
int iPreviousMem = 0;
if (argc != 2)
{
iMem = phys_mem_avail();
std::cout<<std::endl<<"Current Memory Utilization : "<<iMem<<"%"<<std::endl;
std::cout<<std::endl<<"Usage: memorydrinker.exe <N>"<<std::endl;
std::cout<<"\tN is non-zero number : Memory utilization will be increased to N"<<std::endl;
std::cout<<"\tN is 0 : Cache memory will be cleared"<<std::endl<<std::endl;
exit(0);
}
int iPer = atol(argv[1]);
if (iPer <= 0)
{
while (1)
{
system("clear");
iMem = phys_mem_avail();
std::cout<<std::endl<<"Memory Utilization Before Clearing Cache : "<<iMem<<"%"<<std::endl;
system("sync; echo 3 > /proc/sys/vm/drop_caches");
iMem = phys_mem_avail();
std::cout<<std::endl<<"Memory Utilization After Clearing Cache : "<<iMem<<"%"<<std::endl<<std::endl;
sleep(5);
}
}
iMem = phys_mem_avail();
if (iMem > iPer)
system("sync; echo 3 > /proc/sys/vm/drop_caches");
std::cout<<std::endl;
while (1)
{
iMem = phys_mem_avail();
if (iMem >= iPer)
{
std::cout<<std::endl<<"Current Memory Utilization : "<<iMem<<std::endl<<std::endl;
sleep(10);
}
else
{
char *a = new char[255];
if (iPreviousMem < iMem)
{
std::cout<<std::endl<<"Current Memory Utilization : "<<iMem<<"%"<<std::endl;
iPreviousMem = iMem;
}
}
}
std::cout<<"Avail Mem : "<<iMem<<std::endl;
return 0;
}
| [
"send2thiyagu@gmail.com"
] | send2thiyagu@gmail.com |
3b1e0db31f350cce843bfd8778273d05858789a8 | 5123b40e2b826124a9c01023d9fec9d511ae544b | /init/init_turtle.cpp | cd4c108bcd0330dbbe0fa39b42a0d890dc9d236e | [
"MIT"
] | permissive | btwooton/logo | 0e9a5f6647572f8d3a608891796bd0ea5f4dafed | fb55611a7e42606da7fe0fdc4a501741e1d29552 | refs/heads/master | 2020-04-29T14:03:05.047858 | 2019-04-24T03:48:05 | 2019-04-24T03:48:05 | 176,185,285 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 143 | cpp | #include "init_turtle.hpp"
Turtle __turtle__;
void init_turtle(double x, double y, int a, bool pd) {
__turtle__ = Turtle(x, y, a, pd);
}
| [
"gcowootont@gmail.com"
] | gcowootont@gmail.com |
e77e2dda8c1795344d7b34cb9066986f643cf642 | 4ccadd5be8d3ffa1aaffe528b0786a8a956128aa | /paddle/fluid/framework/ir/fuse_optimizer_ops_pass/fuse_sgd_op_pass.cc | 1504f00b27cd6a416761a4227f6c504bb38278bb | [
"Apache-2.0"
] | permissive | yaoxuefeng6/Paddle | 1844879647cca7d725b34f2ddf3be65600f5b321 | e58619295e82b86795da6d29587a17a3efdc486a | refs/heads/develop | 2022-09-06T19:17:26.502784 | 2020-05-13T03:05:26 | 2020-05-13T03:05:26 | 192,290,841 | 1 | 0 | Apache-2.0 | 2022-05-23T10:02:47 | 2019-06-17T06:51:06 | C++ | UTF-8 | C++ | false | false | 2,484 | cc | // Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <algorithm>
#include <string>
#include <unordered_map>
#include <vector>
#include "paddle/fluid/framework/ir/fuse_optimizer_ops_pass/fuse_optimizer_op_pass.h"
#include "paddle/fluid/framework/op_registry.h"
namespace paddle {
namespace framework {
namespace ir {
class FuseSgdOpPass : public FuseOptimizerOpPass {
private:
virtual const std::string GetOpType() const { return "sgd"; }
virtual const std::vector<std::string> GetAuxiliaryVarNames() const {
return {};
}
// Fuse Sgd Ops
virtual ir::Node *FuseOptimizerOps(
const std::unordered_map<std::string, std::vector<std::string>> &vars_set,
const std::unordered_map<std::string, std::string> &fused_vars_name,
const std::vector<ir::Node *> &sgd_ops, ir::Graph *graph) const {
PADDLE_ENFORCE_GT(sgd_ops.size(), static_cast<size_t>(0));
// NOTE: fused_var is only exist in scope, so the graph doesn't have
// fused_var node.
int op_role = BOOST_GET_CONST(
int,
sgd_ops[0]->Op()->GetAttr(OpProtoAndCheckerMaker::OpRoleAttrName()));
VLOG(6) << "Insert sgd to graph.";
// Add fused scale
OpDesc Sgd_desc(sgd_ops[0]->Op()->Block());
Sgd_desc.SetType("sgd");
Sgd_desc.SetInput(kParam, {fused_vars_name.at(kParam)});
Sgd_desc.SetInput(kGrad, {fused_vars_name.at(kGrad)});
Sgd_desc.SetOutput("ParamOut", {fused_vars_name.at(kParam)});
// TODO(zcd): The LearningRate should be equal.
Sgd_desc.SetInput(kLearningRate, sgd_ops[0]->Op()->Input(kLearningRate));
// NOTE: multi_devices_pass requires that every op should have a role.
Sgd_desc.SetAttr(OpProtoAndCheckerMaker::OpRoleAttrName(), op_role);
return graph->CreateOpNode(&Sgd_desc);
}
};
} // namespace ir
} // namespace framework
} // namespace paddle
REGISTER_PASS(fuse_sgd_op_pass, paddle::framework::ir::FuseSgdOpPass);
| [
"noreply@github.com"
] | yaoxuefeng6.noreply@github.com |
b9c7262d6ec5f12624d06a23e207d5f8ca4d6d93 | db48761fc3cb0f8c702c5e66dbd4b683172e53cc | /euler26.cpp | f3b72c41e5e87da621fb861bf9975341b0784232 | [] | no_license | subrataduttauit/Project_Euler | 15e0e6e1dd3182c35fd1833d6ece826c96a2db98 | 9e9b17d6a7d07db23cb7749689bfdfeb0836e09d | refs/heads/master | 2020-04-21T00:37:00.450263 | 2015-08-24T18:59:45 | 2015-08-24T18:59:45 | 40,826,511 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 792 | cpp | /*
* Solution to Project Euler problem 26
* by Subrata Dutta
*
* University Institute of Technology, Burdwan University
* Dept. of Information Technology
* https://github.com/subrataduttauit
* https://in.linkedin.com/in/subrataduttauit
*/
#include <stdio.h>
#include <gmp.h>
#define M 1000
int main(void)
{
mpz_t p, r;
unsigned maxlen = 0, imax = 0;
unsigned i;
mpz_init(p); mpz_init(r);
for (i = 2; i < M; i++) {
unsigned len = 1;
if (i % 2 == 0 || i % 5 == 0) {
continue;
}
mpz_set_ui(p, 10);
while (mpz_mod_ui(r, p, i), mpz_cmp_ui(r, 1) != 0) {
len++;
mpz_mul_ui(p, p, 10);
}
if (len > maxlen) {
maxlen = len;
imax = i;
}
}
printf("%u\n", imax);
mpz_clear(p);
mpz_clear(r);
return 0;
}
| [
"subrataduttauit@gmail.com"
] | subrataduttauit@gmail.com |
94ee47dad36c66bd67aab50f4e9acbdd86d5d1f7 | 3b4db29ebde79579801d8952e8c84d4fcefb81bc | /PortableTimer.h | 4c0f917b4de4eed967993f336f7438b68710886e | [] | no_license | shusenl/simple-glsl-raycaster | beeb5f2b679e89733e3aa7c6050e4a0469ae9ca3 | b35ec4317b43924f0f861d0fe8e186224db3c485 | refs/heads/master | 2021-03-12T21:19:48.424678 | 2015-10-06T05:37:44 | 2015-10-06T05:37:44 | 43,574,771 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 831 | h | #ifndef _PORTABLE_TIMER_H
#define _PORTABLE_TIMER_H
#ifdef WIN32
#include <windows.h>
#endif
//TODO portability
class PortableTimer
{
public:
void Init();
void StartTimer();
void EndTimer();
float GetTimeSecond();
private:
#ifdef WIN32
LARGE_INTEGER _ticksPerSecond;
LARGE_INTEGER _tic, _toc;
#endif
};
inline void PortableTimer::Init()
{
#ifdef WIN32
QueryPerformanceFrequency(&_ticksPerSecond);
#endif
}
inline void PortableTimer::StartTimer()
{
#ifdef WIN32
QueryPerformanceCounter(&_tic);
#endif
}
inline void PortableTimer::EndTimer()
{
#ifdef WIN32
QueryPerformanceCounter(&_toc);
#endif
}
inline float PortableTimer::GetTimeSecond()
{
#ifdef WIN32
return float(_toc.LowPart-_tic.LowPart)/float(_ticksPerSecond.LowPart);
#endif
}
#endif
| [
"shusenl@sci.utah.edu"
] | shusenl@sci.utah.edu |
b0e1fe68dd80246bc7481ef82b5d03aa35dce320 | a28b4a82e787e1a35424386b63a4f9e9cf2f6585 | /DSAlgoPrep/WordLadderDFS.cpp | 4b4667ab1102a45e577dd6a4bc9bce7f3404c17a | [] | no_license | SorrowfulBlinger/DSAlgoPrep | 03e046b0b3ae0caf058b2f75effba936f07dcccf | 6400f87d580b8353ecef3b2f085e92ee62d510f8 | refs/heads/master | 2022-10-20T16:09:50.445299 | 2020-07-19T18:29:55 | 2020-07-19T18:29:55 | 280,924,540 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 119 | cpp | #include "pch.h"
#include "WordLadderDFS.h"
WordLadderDFS::WordLadderDFS()
{
}
WordLadderDFS::~WordLadderDFS()
{
}
| [
"purushot@adobe.com"
] | purushot@adobe.com |
addd253e1a3c362ab891d9b4e731dd44f921f587 | 48af55400936b704d3d4458d48cee1b187c8f9d6 | /Nhan_Hai_So_Nguyen_Lon.cpp | cdb944f7ed5468032a6eb614ddad0597ba22cdc0 | [] | no_license | BuiHuyHieu/BaitapC-Cplusplus | 907848c6a4284f314f806ce52258e61207843499 | b60e6c1edfddf6ae79779758b574bcaf899919ac | refs/heads/master | 2020-04-19T17:16:35.989076 | 2019-04-29T15:06:23 | 2019-04-29T15:06:23 | 168,330,091 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,181 | cpp | #include<bits/stdc++.h>
using namespace std;
int StoI(char CHAR)
{
return int(CHAR)-48;
}
string nhan(string Bignumber, int number)
{
string tempNumBer="";
int i,sum,mod=0;
for(i=Bignumber.size()-1;i>=0;i--)
{
//int mod=0;
char temp = StoI(Bignumber[i]);
sum = temp*number+mod;
if(i==0)
{
ostringstream convert; // khai bao phuong thuc chuyen so sang xau
//int sum1 = sum+mod;
convert << sum; // dua so vao phuong thuc
string tempo = convert.str(); // chuyen tu so sang xau
tempNumBer = tempo + tempNumBer;
}
else
{
mod = sum/10;
int les = sum-mod*10;
char nb = les+48;
tempNumBer = nb+tempNumBer;
}
}
return tempNumBer;
}
string cong(string pharse1, string pharse2)
{
string temp,temp1,res="";
if (pharse1.size()>pharse2.size())
{
temp=pharse2;
temp1=pharse1;
}
else
{
temp=pharse1;
temp1=pharse2;
};
int i,mod=0,j,dem,t,t1,plut,sum;
i=temp.size();
j=temp1.size()-1;
for(dem=0;dem<(j-i+1);dem++)
temp="0"+temp;
while (j>=0)
{
if(j==0)
{
ostringstream convert;
t=StoI(temp[j]);
t1=StoI(temp1[j]);
int sum1 = t+t1+mod;
convert << sum1;
string tempo = convert.str();
res= tempo + res;
}
else
{
t=StoI(temp[j]);
t1=StoI(temp1[j]);
sum=t+t1+mod;
mod=(t+t1)/10;
plut = sum-mod*10;
res = (char) (plut+48)+res ;
}
j--;
}
return res ;
}
string Purpose(string Number1, string Number2)
{
int i=Number2.size()-1;
int dem,run,j,j1;
string k1="0",temp;
for(run=i;run>=0;run--)
{
temp=nhan(Number1,StoI(Number2[run]));
for(j1=0;j1<j;j1++)
temp=temp+"0";
j++;
k1=cong(k1,temp);
}
return k1;
}
int main()
{
string Number1,Number2;
cout <<"Enter Number1: ";
cin >>Number1;
cout <<"Enter Number2: ";
cin >>Number2;
cout <<Purpose(Number1,Number2);
}
| [
"noreply@github.com"
] | BuiHuyHieu.noreply@github.com |
680fa97c804b921412b1e7bca719e7d1fdff2e24 | 65e13aab6c33b887c93d3150a2da058c2e75dfad | /Easy/Easy028/main.cpp | 9ac4cc56150d19b5c1b0c8a476696d58f1e0f1c8 | [] | no_license | ianw3214/DailyProgrammer | 8e50a6044df41be89706c489a8f5e16227ad84aa | 75afe10117bd20cee2f3d9851b864ddcd542f3f2 | refs/heads/master | 2021-01-19T02:05:05.757632 | 2017-12-10T07:03:19 | 2017-12-10T07:03:19 | 56,127,360 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 934 | cpp | /* Duplicate finding program
*/
#include <iostream>
#include <vector>
// function declarations
int getDuplicate(std::vector<int>);
int main() {
// the vector to put through the function
std::vector<int> input = { 1, 5, 6, 7, 2, 3, 4, 9, 2};
// run the function and store to an integer
int output = getDuplicate(input);
// output the result
std::cout << "The duplicate of the vector is: " << output << std::endl;
system("PAUSE");
return 0;
}
// function to return 1 duplicate number in an array
int getDuplicate(std::vector<int> inp) {
// loop through the input vector
for (int i = 0; i < inp.size(); i++) {
// loop through the rest of the vector from the next element
for (int j = i + 1; j < inp.size(); j++) {
// if the two elements are the same
if (inp.at(i) == inp.at(j)) {
// return the number
return inp.at(i);
}
}
}
// there are no duplicates if the function runs here
return 0;
} | [
"ianw3214@gmail.com"
] | ianw3214@gmail.com |
015338e0791115da77283a3c863dd69867f4b2fd | d66e2695d16579ca62ac8f208299606688ab9245 | /vulkan/vulkan_handles.hpp | 502bc96ba7bd84199885119c36b1053b9e3b99e8 | [
"Apache-2.0"
] | permissive | EhmedBelal/Vulkan-Hpp | db756fa7d1652d0e7237f2d1b59ec99ec6359a78 | 729550951cc290b4e8166ba9b4b2c59cced164fb | refs/heads/master | 2023-07-26T21:00:35.494536 | 2021-09-14T07:38:20 | 2021-09-14T07:38:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 781,044 | hpp | // Copyright 2015-2021 The Khronos Group Inc.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//
// This header is generated from the Khronos Vulkan XML API Registry.
#ifndef VULKAN_HANDLES_HPP
#define VULKAN_HANDLES_HPP
namespace VULKAN_HPP_NAMESPACE
{
//===================================
//=== STRUCT forward declarations ===
//===================================
//=== VK_VERSION_1_0 ===
struct Extent2D;
struct Extent3D;
struct Offset2D;
struct Offset3D;
struct Rect2D;
struct BaseInStructure;
struct BaseOutStructure;
struct BufferMemoryBarrier;
struct DispatchIndirectCommand;
struct DrawIndexedIndirectCommand;
struct DrawIndirectCommand;
struct ImageMemoryBarrier;
struct MemoryBarrier;
struct PipelineCacheHeaderVersionOne;
struct AllocationCallbacks;
struct ApplicationInfo;
struct FormatProperties;
struct ImageFormatProperties;
struct InstanceCreateInfo;
struct MemoryHeap;
struct MemoryType;
struct PhysicalDeviceFeatures;
struct PhysicalDeviceLimits;
struct PhysicalDeviceMemoryProperties;
struct PhysicalDeviceProperties;
struct PhysicalDeviceSparseProperties;
struct QueueFamilyProperties;
struct DeviceCreateInfo;
struct DeviceQueueCreateInfo;
struct ExtensionProperties;
struct LayerProperties;
struct SubmitInfo;
struct MappedMemoryRange;
struct MemoryAllocateInfo;
struct MemoryRequirements;
struct BindSparseInfo;
struct ImageSubresource;
struct SparseBufferMemoryBindInfo;
struct SparseImageFormatProperties;
struct SparseImageMemoryBind;
struct SparseImageMemoryBindInfo;
struct SparseImageMemoryRequirements;
struct SparseImageOpaqueMemoryBindInfo;
struct SparseMemoryBind;
struct FenceCreateInfo;
struct SemaphoreCreateInfo;
struct EventCreateInfo;
struct QueryPoolCreateInfo;
struct BufferCreateInfo;
struct BufferViewCreateInfo;
struct ImageCreateInfo;
struct SubresourceLayout;
struct ComponentMapping;
struct ImageSubresourceRange;
struct ImageViewCreateInfo;
struct ShaderModuleCreateInfo;
struct PipelineCacheCreateInfo;
struct ComputePipelineCreateInfo;
struct GraphicsPipelineCreateInfo;
struct PipelineColorBlendAttachmentState;
struct PipelineColorBlendStateCreateInfo;
struct PipelineDepthStencilStateCreateInfo;
struct PipelineDynamicStateCreateInfo;
struct PipelineInputAssemblyStateCreateInfo;
struct PipelineMultisampleStateCreateInfo;
struct PipelineRasterizationStateCreateInfo;
struct PipelineShaderStageCreateInfo;
struct PipelineTessellationStateCreateInfo;
struct PipelineVertexInputStateCreateInfo;
struct PipelineViewportStateCreateInfo;
struct SpecializationInfo;
struct SpecializationMapEntry;
struct StencilOpState;
struct VertexInputAttributeDescription;
struct VertexInputBindingDescription;
struct Viewport;
struct PipelineLayoutCreateInfo;
struct PushConstantRange;
struct SamplerCreateInfo;
struct CopyDescriptorSet;
struct DescriptorBufferInfo;
struct DescriptorImageInfo;
struct DescriptorPoolCreateInfo;
struct DescriptorPoolSize;
struct DescriptorSetAllocateInfo;
struct DescriptorSetLayoutBinding;
struct DescriptorSetLayoutCreateInfo;
struct WriteDescriptorSet;
struct AttachmentDescription;
struct AttachmentReference;
struct FramebufferCreateInfo;
struct RenderPassCreateInfo;
struct SubpassDependency;
struct SubpassDescription;
struct CommandPoolCreateInfo;
struct CommandBufferAllocateInfo;
struct CommandBufferBeginInfo;
struct CommandBufferInheritanceInfo;
struct BufferCopy;
struct BufferImageCopy;
struct ClearAttachment;
union ClearColorValue;
struct ClearDepthStencilValue;
struct ClearRect;
union ClearValue;
struct ImageBlit;
struct ImageCopy;
struct ImageResolve;
struct ImageSubresourceLayers;
struct RenderPassBeginInfo;
//=== VK_VERSION_1_1 ===
struct PhysicalDeviceSubgroupProperties;
struct BindBufferMemoryInfo;
using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
struct BindImageMemoryInfo;
using BindImageMemoryInfoKHR = BindImageMemoryInfo;
struct PhysicalDevice16BitStorageFeatures;
using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
struct MemoryDedicatedRequirements;
using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
struct MemoryDedicatedAllocateInfo;
using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
struct MemoryAllocateFlagsInfo;
using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
struct DeviceGroupRenderPassBeginInfo;
using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
struct DeviceGroupCommandBufferBeginInfo;
using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
struct DeviceGroupSubmitInfo;
using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
struct DeviceGroupBindSparseInfo;
using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
struct BindBufferMemoryDeviceGroupInfo;
using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
struct BindImageMemoryDeviceGroupInfo;
using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
struct PhysicalDeviceGroupProperties;
using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
struct DeviceGroupDeviceCreateInfo;
using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
struct BufferMemoryRequirementsInfo2;
using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
struct ImageMemoryRequirementsInfo2;
using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
struct ImageSparseMemoryRequirementsInfo2;
using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
struct MemoryRequirements2;
using MemoryRequirements2KHR = MemoryRequirements2;
struct SparseImageMemoryRequirements2;
using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
struct PhysicalDeviceFeatures2;
using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
struct PhysicalDeviceProperties2;
using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
struct FormatProperties2;
using FormatProperties2KHR = FormatProperties2;
struct ImageFormatProperties2;
using ImageFormatProperties2KHR = ImageFormatProperties2;
struct PhysicalDeviceImageFormatInfo2;
using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
struct QueueFamilyProperties2;
using QueueFamilyProperties2KHR = QueueFamilyProperties2;
struct PhysicalDeviceMemoryProperties2;
using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
struct SparseImageFormatProperties2;
using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
struct PhysicalDeviceSparseImageFormatInfo2;
using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
struct PhysicalDevicePointClippingProperties;
using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
struct RenderPassInputAttachmentAspectCreateInfo;
using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
struct InputAttachmentAspectReference;
using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
struct ImageViewUsageCreateInfo;
using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
struct PipelineTessellationDomainOriginStateCreateInfo;
using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
struct RenderPassMultiviewCreateInfo;
using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
struct PhysicalDeviceMultiviewFeatures;
using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
struct PhysicalDeviceMultiviewProperties;
using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
struct PhysicalDeviceVariablePointersFeatures;
using PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures;
using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
struct PhysicalDeviceProtectedMemoryFeatures;
struct PhysicalDeviceProtectedMemoryProperties;
struct DeviceQueueInfo2;
struct ProtectedSubmitInfo;
struct SamplerYcbcrConversionCreateInfo;
using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
struct SamplerYcbcrConversionInfo;
using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
struct BindImagePlaneMemoryInfo;
using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
struct ImagePlaneMemoryRequirementsInfo;
using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
struct PhysicalDeviceSamplerYcbcrConversionFeatures;
using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
struct SamplerYcbcrConversionImageFormatProperties;
using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;
struct DescriptorUpdateTemplateEntry;
using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
struct DescriptorUpdateTemplateCreateInfo;
using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
struct ExternalMemoryProperties;
using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
struct PhysicalDeviceExternalImageFormatInfo;
using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
struct ExternalImageFormatProperties;
using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
struct PhysicalDeviceExternalBufferInfo;
using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
struct ExternalBufferProperties;
using ExternalBufferPropertiesKHR = ExternalBufferProperties;
struct PhysicalDeviceIDProperties;
using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
struct ExternalMemoryImageCreateInfo;
using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
struct ExternalMemoryBufferCreateInfo;
using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
struct ExportMemoryAllocateInfo;
using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
struct PhysicalDeviceExternalFenceInfo;
using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
struct ExternalFenceProperties;
using ExternalFencePropertiesKHR = ExternalFenceProperties;
struct ExportFenceCreateInfo;
using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
struct ExportSemaphoreCreateInfo;
using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
struct PhysicalDeviceExternalSemaphoreInfo;
using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
struct ExternalSemaphoreProperties;
using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
struct PhysicalDeviceMaintenance3Properties;
using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
struct DescriptorSetLayoutSupport;
using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
struct PhysicalDeviceShaderDrawParametersFeatures;
using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
//=== VK_VERSION_1_2 ===
struct PhysicalDeviceVulkan11Features;
struct PhysicalDeviceVulkan11Properties;
struct PhysicalDeviceVulkan12Features;
struct PhysicalDeviceVulkan12Properties;
struct ImageFormatListCreateInfo;
using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
struct RenderPassCreateInfo2;
using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
struct AttachmentDescription2;
using AttachmentDescription2KHR = AttachmentDescription2;
struct AttachmentReference2;
using AttachmentReference2KHR = AttachmentReference2;
struct SubpassDescription2;
using SubpassDescription2KHR = SubpassDescription2;
struct SubpassDependency2;
using SubpassDependency2KHR = SubpassDependency2;
struct SubpassBeginInfo;
using SubpassBeginInfoKHR = SubpassBeginInfo;
struct SubpassEndInfo;
using SubpassEndInfoKHR = SubpassEndInfo;
struct PhysicalDevice8BitStorageFeatures;
using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
struct ConformanceVersion;
using ConformanceVersionKHR = ConformanceVersion;
struct PhysicalDeviceDriverProperties;
using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
struct PhysicalDeviceShaderAtomicInt64Features;
using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
struct PhysicalDeviceShaderFloat16Int8Features;
using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
struct PhysicalDeviceFloatControlsProperties;
using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
struct DescriptorSetLayoutBindingFlagsCreateInfo;
using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
struct PhysicalDeviceDescriptorIndexingFeatures;
using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
struct PhysicalDeviceDescriptorIndexingProperties;
using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
struct DescriptorSetVariableDescriptorCountAllocateInfo;
using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;
struct DescriptorSetVariableDescriptorCountLayoutSupport;
using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;
struct SubpassDescriptionDepthStencilResolve;
using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
struct PhysicalDeviceDepthStencilResolveProperties;
using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;
struct PhysicalDeviceScalarBlockLayoutFeatures;
using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
struct ImageStencilUsageCreateInfo;
using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
struct SamplerReductionModeCreateInfo;
using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
struct PhysicalDeviceSamplerFilterMinmaxProperties;
using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
struct PhysicalDeviceVulkanMemoryModelFeatures;
using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
struct PhysicalDeviceImagelessFramebufferFeatures;
using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
struct FramebufferAttachmentsCreateInfo;
using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
struct FramebufferAttachmentImageInfo;
using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
struct RenderPassAttachmentBeginInfo;
using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
struct PhysicalDeviceUniformBufferStandardLayoutFeatures;
using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;
struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
struct AttachmentReferenceStencilLayout;
using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
struct AttachmentDescriptionStencilLayout;
using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
struct PhysicalDeviceHostQueryResetFeatures;
using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
struct PhysicalDeviceTimelineSemaphoreFeatures;
using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
struct PhysicalDeviceTimelineSemaphoreProperties;
using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
struct SemaphoreTypeCreateInfo;
using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
struct TimelineSemaphoreSubmitInfo;
using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
struct SemaphoreWaitInfo;
using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
struct SemaphoreSignalInfo;
using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
struct PhysicalDeviceBufferDeviceAddressFeatures;
using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
struct BufferDeviceAddressInfo;
using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
struct BufferOpaqueCaptureAddressCreateInfo;
using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
struct MemoryOpaqueCaptureAddressAllocateInfo;
using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
struct DeviceMemoryOpaqueCaptureAddressInfo;
using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
//=== VK_KHR_surface ===
struct SurfaceCapabilitiesKHR;
struct SurfaceFormatKHR;
//=== VK_KHR_swapchain ===
struct SwapchainCreateInfoKHR;
struct PresentInfoKHR;
struct ImageSwapchainCreateInfoKHR;
struct BindImageMemorySwapchainInfoKHR;
struct AcquireNextImageInfoKHR;
struct DeviceGroupPresentCapabilitiesKHR;
struct DeviceGroupPresentInfoKHR;
struct DeviceGroupSwapchainCreateInfoKHR;
//=== VK_KHR_display ===
struct DisplayModeCreateInfoKHR;
struct DisplayModeParametersKHR;
struct DisplayModePropertiesKHR;
struct DisplayPlaneCapabilitiesKHR;
struct DisplayPlanePropertiesKHR;
struct DisplayPropertiesKHR;
struct DisplaySurfaceCreateInfoKHR;
//=== VK_KHR_display_swapchain ===
struct DisplayPresentInfoKHR;
#if defined( VK_USE_PLATFORM_XLIB_KHR )
//=== VK_KHR_xlib_surface ===
struct XlibSurfaceCreateInfoKHR;
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
#if defined( VK_USE_PLATFORM_XCB_KHR )
//=== VK_KHR_xcb_surface ===
struct XcbSurfaceCreateInfoKHR;
#endif /*VK_USE_PLATFORM_XCB_KHR*/
#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
//=== VK_KHR_wayland_surface ===
struct WaylandSurfaceCreateInfoKHR;
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_KHR_android_surface ===
struct AndroidSurfaceCreateInfoKHR;
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_win32_surface ===
struct Win32SurfaceCreateInfoKHR;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_debug_report ===
struct DebugReportCallbackCreateInfoEXT;
//=== VK_AMD_rasterization_order ===
struct PipelineRasterizationStateRasterizationOrderAMD;
//=== VK_EXT_debug_marker ===
struct DebugMarkerObjectNameInfoEXT;
struct DebugMarkerObjectTagInfoEXT;
struct DebugMarkerMarkerInfoEXT;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_video_queue ===
struct VideoQueueFamilyProperties2KHR;
struct VideoProfileKHR;
struct VideoProfilesKHR;
struct VideoCapabilitiesKHR;
struct PhysicalDeviceVideoFormatInfoKHR;
struct VideoFormatPropertiesKHR;
struct VideoPictureResourceKHR;
struct VideoReferenceSlotKHR;
struct VideoGetMemoryPropertiesKHR;
struct VideoBindMemoryKHR;
struct VideoSessionCreateInfoKHR;
struct VideoSessionParametersCreateInfoKHR;
struct VideoSessionParametersUpdateInfoKHR;
struct VideoBeginCodingInfoKHR;
struct VideoEndCodingInfoKHR;
struct VideoCodingControlInfoKHR;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_video_decode_queue ===
struct VideoDecodeInfoKHR;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_NV_dedicated_allocation ===
struct DedicatedAllocationImageCreateInfoNV;
struct DedicatedAllocationBufferCreateInfoNV;
struct DedicatedAllocationMemoryAllocateInfoNV;
//=== VK_EXT_transform_feedback ===
struct PhysicalDeviceTransformFeedbackFeaturesEXT;
struct PhysicalDeviceTransformFeedbackPropertiesEXT;
struct PipelineRasterizationStateStreamCreateInfoEXT;
//=== VK_NVX_binary_import ===
struct CuModuleCreateInfoNVX;
struct CuFunctionCreateInfoNVX;
struct CuLaunchInfoNVX;
//=== VK_NVX_image_view_handle ===
struct ImageViewHandleInfoNVX;
struct ImageViewAddressPropertiesNVX;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_encode_h264 ===
struct VideoEncodeH264CapabilitiesEXT;
struct VideoEncodeH264SessionCreateInfoEXT;
struct VideoEncodeH264SessionParametersCreateInfoEXT;
struct VideoEncodeH264SessionParametersAddInfoEXT;
struct VideoEncodeH264VclFrameInfoEXT;
struct VideoEncodeH264EmitPictureParametersEXT;
struct VideoEncodeH264DpbSlotInfoEXT;
struct VideoEncodeH264NaluSliceEXT;
struct VideoEncodeH264ProfileEXT;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_decode_h264 ===
struct VideoDecodeH264ProfileEXT;
struct VideoDecodeH264CapabilitiesEXT;
struct VideoDecodeH264SessionCreateInfoEXT;
struct VideoDecodeH264SessionParametersCreateInfoEXT;
struct VideoDecodeH264SessionParametersAddInfoEXT;
struct VideoDecodeH264PictureInfoEXT;
struct VideoDecodeH264MvcEXT;
struct VideoDecodeH264DpbSlotInfoEXT;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_AMD_texture_gather_bias_lod ===
struct TextureLODGatherFormatPropertiesAMD;
//=== VK_AMD_shader_info ===
struct ShaderResourceUsageAMD;
struct ShaderStatisticsInfoAMD;
#if defined( VK_USE_PLATFORM_GGP )
//=== VK_GGP_stream_descriptor_surface ===
struct StreamDescriptorSurfaceCreateInfoGGP;
#endif /*VK_USE_PLATFORM_GGP*/
//=== VK_NV_corner_sampled_image ===
struct PhysicalDeviceCornerSampledImageFeaturesNV;
//=== VK_NV_external_memory_capabilities ===
struct ExternalImageFormatPropertiesNV;
//=== VK_NV_external_memory ===
struct ExternalMemoryImageCreateInfoNV;
struct ExportMemoryAllocateInfoNV;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_external_memory_win32 ===
struct ImportMemoryWin32HandleInfoNV;
struct ExportMemoryWin32HandleInfoNV;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_win32_keyed_mutex ===
struct Win32KeyedMutexAcquireReleaseInfoNV;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_validation_flags ===
struct ValidationFlagsEXT;
#if defined( VK_USE_PLATFORM_VI_NN )
//=== VK_NN_vi_surface ===
struct ViSurfaceCreateInfoNN;
#endif /*VK_USE_PLATFORM_VI_NN*/
//=== VK_EXT_texture_compression_astc_hdr ===
struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
//=== VK_EXT_astc_decode_mode ===
struct ImageViewASTCDecodeModeEXT;
struct PhysicalDeviceASTCDecodeFeaturesEXT;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_memory_win32 ===
struct ImportMemoryWin32HandleInfoKHR;
struct ExportMemoryWin32HandleInfoKHR;
struct MemoryWin32HandlePropertiesKHR;
struct MemoryGetWin32HandleInfoKHR;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_memory_fd ===
struct ImportMemoryFdInfoKHR;
struct MemoryFdPropertiesKHR;
struct MemoryGetFdInfoKHR;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_win32_keyed_mutex ===
struct Win32KeyedMutexAcquireReleaseInfoKHR;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_semaphore_win32 ===
struct ImportSemaphoreWin32HandleInfoKHR;
struct ExportSemaphoreWin32HandleInfoKHR;
struct D3D12FenceSubmitInfoKHR;
struct SemaphoreGetWin32HandleInfoKHR;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_semaphore_fd ===
struct ImportSemaphoreFdInfoKHR;
struct SemaphoreGetFdInfoKHR;
//=== VK_KHR_push_descriptor ===
struct PhysicalDevicePushDescriptorPropertiesKHR;
//=== VK_EXT_conditional_rendering ===
struct ConditionalRenderingBeginInfoEXT;
struct PhysicalDeviceConditionalRenderingFeaturesEXT;
struct CommandBufferInheritanceConditionalRenderingInfoEXT;
//=== VK_KHR_incremental_present ===
struct PresentRegionsKHR;
struct PresentRegionKHR;
struct RectLayerKHR;
//=== VK_NV_clip_space_w_scaling ===
struct ViewportWScalingNV;
struct PipelineViewportWScalingStateCreateInfoNV;
//=== VK_EXT_display_surface_counter ===
struct SurfaceCapabilities2EXT;
//=== VK_EXT_display_control ===
struct DisplayPowerInfoEXT;
struct DeviceEventInfoEXT;
struct DisplayEventInfoEXT;
struct SwapchainCounterCreateInfoEXT;
//=== VK_GOOGLE_display_timing ===
struct RefreshCycleDurationGOOGLE;
struct PastPresentationTimingGOOGLE;
struct PresentTimesInfoGOOGLE;
struct PresentTimeGOOGLE;
//=== VK_NVX_multiview_per_view_attributes ===
struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
//=== VK_NV_viewport_swizzle ===
struct ViewportSwizzleNV;
struct PipelineViewportSwizzleStateCreateInfoNV;
//=== VK_EXT_discard_rectangles ===
struct PhysicalDeviceDiscardRectanglePropertiesEXT;
struct PipelineDiscardRectangleStateCreateInfoEXT;
//=== VK_EXT_conservative_rasterization ===
struct PhysicalDeviceConservativeRasterizationPropertiesEXT;
struct PipelineRasterizationConservativeStateCreateInfoEXT;
//=== VK_EXT_depth_clip_enable ===
struct PhysicalDeviceDepthClipEnableFeaturesEXT;
struct PipelineRasterizationDepthClipStateCreateInfoEXT;
//=== VK_EXT_hdr_metadata ===
struct HdrMetadataEXT;
struct XYColorEXT;
//=== VK_KHR_shared_presentable_image ===
struct SharedPresentSurfaceCapabilitiesKHR;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_fence_win32 ===
struct ImportFenceWin32HandleInfoKHR;
struct ExportFenceWin32HandleInfoKHR;
struct FenceGetWin32HandleInfoKHR;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_fence_fd ===
struct ImportFenceFdInfoKHR;
struct FenceGetFdInfoKHR;
//=== VK_KHR_performance_query ===
struct PhysicalDevicePerformanceQueryFeaturesKHR;
struct PhysicalDevicePerformanceQueryPropertiesKHR;
struct PerformanceCounterKHR;
struct PerformanceCounterDescriptionKHR;
struct QueryPoolPerformanceCreateInfoKHR;
union PerformanceCounterResultKHR;
struct AcquireProfilingLockInfoKHR;
struct PerformanceQuerySubmitInfoKHR;
//=== VK_KHR_get_surface_capabilities2 ===
struct PhysicalDeviceSurfaceInfo2KHR;
struct SurfaceCapabilities2KHR;
struct SurfaceFormat2KHR;
//=== VK_KHR_get_display_properties2 ===
struct DisplayProperties2KHR;
struct DisplayPlaneProperties2KHR;
struct DisplayModeProperties2KHR;
struct DisplayPlaneInfo2KHR;
struct DisplayPlaneCapabilities2KHR;
#if defined( VK_USE_PLATFORM_IOS_MVK )
//=== VK_MVK_ios_surface ===
struct IOSSurfaceCreateInfoMVK;
#endif /*VK_USE_PLATFORM_IOS_MVK*/
#if defined( VK_USE_PLATFORM_MACOS_MVK )
//=== VK_MVK_macos_surface ===
struct MacOSSurfaceCreateInfoMVK;
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
//=== VK_EXT_debug_utils ===
struct DebugUtilsLabelEXT;
struct DebugUtilsMessengerCallbackDataEXT;
struct DebugUtilsMessengerCreateInfoEXT;
struct DebugUtilsObjectNameInfoEXT;
struct DebugUtilsObjectTagInfoEXT;
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_ANDROID_external_memory_android_hardware_buffer ===
struct AndroidHardwareBufferUsageANDROID;
struct AndroidHardwareBufferPropertiesANDROID;
struct AndroidHardwareBufferFormatPropertiesANDROID;
struct ImportAndroidHardwareBufferInfoANDROID;
struct MemoryGetAndroidHardwareBufferInfoANDROID;
struct ExternalFormatANDROID;
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
//=== VK_EXT_inline_uniform_block ===
struct PhysicalDeviceInlineUniformBlockFeaturesEXT;
struct PhysicalDeviceInlineUniformBlockPropertiesEXT;
struct WriteDescriptorSetInlineUniformBlockEXT;
struct DescriptorPoolInlineUniformBlockCreateInfoEXT;
//=== VK_EXT_sample_locations ===
struct SampleLocationEXT;
struct SampleLocationsInfoEXT;
struct AttachmentSampleLocationsEXT;
struct SubpassSampleLocationsEXT;
struct RenderPassSampleLocationsBeginInfoEXT;
struct PipelineSampleLocationsStateCreateInfoEXT;
struct PhysicalDeviceSampleLocationsPropertiesEXT;
struct MultisamplePropertiesEXT;
//=== VK_EXT_blend_operation_advanced ===
struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
struct PipelineColorBlendAdvancedStateCreateInfoEXT;
//=== VK_NV_fragment_coverage_to_color ===
struct PipelineCoverageToColorStateCreateInfoNV;
//=== VK_KHR_acceleration_structure ===
union DeviceOrHostAddressKHR;
union DeviceOrHostAddressConstKHR;
struct AccelerationStructureBuildRangeInfoKHR;
struct AabbPositionsKHR;
using AabbPositionsNV = AabbPositionsKHR;
struct AccelerationStructureGeometryTrianglesDataKHR;
struct TransformMatrixKHR;
using TransformMatrixNV = TransformMatrixKHR;
struct AccelerationStructureBuildGeometryInfoKHR;
struct AccelerationStructureGeometryAabbsDataKHR;
struct AccelerationStructureInstanceKHR;
using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
struct AccelerationStructureGeometryInstancesDataKHR;
union AccelerationStructureGeometryDataKHR;
struct AccelerationStructureGeometryKHR;
struct AccelerationStructureCreateInfoKHR;
struct WriteDescriptorSetAccelerationStructureKHR;
struct PhysicalDeviceAccelerationStructureFeaturesKHR;
struct PhysicalDeviceAccelerationStructurePropertiesKHR;
struct AccelerationStructureDeviceAddressInfoKHR;
struct AccelerationStructureVersionInfoKHR;
struct CopyAccelerationStructureToMemoryInfoKHR;
struct CopyMemoryToAccelerationStructureInfoKHR;
struct CopyAccelerationStructureInfoKHR;
struct AccelerationStructureBuildSizesInfoKHR;
//=== VK_NV_framebuffer_mixed_samples ===
struct PipelineCoverageModulationStateCreateInfoNV;
//=== VK_NV_shader_sm_builtins ===
struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;
struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;
//=== VK_EXT_image_drm_format_modifier ===
struct DrmFormatModifierPropertiesListEXT;
struct DrmFormatModifierPropertiesEXT;
struct PhysicalDeviceImageDrmFormatModifierInfoEXT;
struct ImageDrmFormatModifierListCreateInfoEXT;
struct ImageDrmFormatModifierExplicitCreateInfoEXT;
struct ImageDrmFormatModifierPropertiesEXT;
//=== VK_EXT_validation_cache ===
struct ValidationCacheCreateInfoEXT;
struct ShaderModuleValidationCacheCreateInfoEXT;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_portability_subset ===
struct PhysicalDevicePortabilitySubsetFeaturesKHR;
struct PhysicalDevicePortabilitySubsetPropertiesKHR;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_NV_shading_rate_image ===
struct ShadingRatePaletteNV;
struct PipelineViewportShadingRateImageStateCreateInfoNV;
struct PhysicalDeviceShadingRateImageFeaturesNV;
struct PhysicalDeviceShadingRateImagePropertiesNV;
struct CoarseSampleLocationNV;
struct CoarseSampleOrderCustomNV;
struct PipelineViewportCoarseSampleOrderStateCreateInfoNV;
//=== VK_NV_ray_tracing ===
struct RayTracingShaderGroupCreateInfoNV;
struct RayTracingPipelineCreateInfoNV;
struct GeometryTrianglesNV;
struct GeometryAABBNV;
struct GeometryDataNV;
struct GeometryNV;
struct AccelerationStructureInfoNV;
struct AccelerationStructureCreateInfoNV;
struct BindAccelerationStructureMemoryInfoNV;
struct WriteDescriptorSetAccelerationStructureNV;
struct AccelerationStructureMemoryRequirementsInfoNV;
struct PhysicalDeviceRayTracingPropertiesNV;
//=== VK_NV_representative_fragment_test ===
struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
struct PipelineRepresentativeFragmentTestStateCreateInfoNV;
//=== VK_EXT_filter_cubic ===
struct PhysicalDeviceImageViewImageFormatInfoEXT;
struct FilterCubicImageViewImageFormatPropertiesEXT;
//=== VK_EXT_global_priority ===
struct DeviceQueueGlobalPriorityCreateInfoEXT;
//=== VK_EXT_external_memory_host ===
struct ImportMemoryHostPointerInfoEXT;
struct MemoryHostPointerPropertiesEXT;
struct PhysicalDeviceExternalMemoryHostPropertiesEXT;
//=== VK_KHR_shader_clock ===
struct PhysicalDeviceShaderClockFeaturesKHR;
//=== VK_AMD_pipeline_compiler_control ===
struct PipelineCompilerControlCreateInfoAMD;
//=== VK_EXT_calibrated_timestamps ===
struct CalibratedTimestampInfoEXT;
//=== VK_AMD_shader_core_properties ===
struct PhysicalDeviceShaderCorePropertiesAMD;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_decode_h265 ===
struct VideoDecodeH265ProfileEXT;
struct VideoDecodeH265CapabilitiesEXT;
struct VideoDecodeH265SessionCreateInfoEXT;
struct VideoDecodeH265SessionParametersCreateInfoEXT;
struct VideoDecodeH265SessionParametersAddInfoEXT;
struct VideoDecodeH265PictureInfoEXT;
struct VideoDecodeH265DpbSlotInfoEXT;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_AMD_memory_overallocation_behavior ===
struct DeviceMemoryOverallocationCreateInfoAMD;
//=== VK_EXT_vertex_attribute_divisor ===
struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
struct VertexInputBindingDivisorDescriptionEXT;
struct PipelineVertexInputDivisorStateCreateInfoEXT;
struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
#if defined( VK_USE_PLATFORM_GGP )
//=== VK_GGP_frame_token ===
struct PresentFrameTokenGGP;
#endif /*VK_USE_PLATFORM_GGP*/
//=== VK_EXT_pipeline_creation_feedback ===
struct PipelineCreationFeedbackCreateInfoEXT;
struct PipelineCreationFeedbackEXT;
//=== VK_NV_compute_shader_derivatives ===
struct PhysicalDeviceComputeShaderDerivativesFeaturesNV;
//=== VK_NV_mesh_shader ===
struct PhysicalDeviceMeshShaderFeaturesNV;
struct PhysicalDeviceMeshShaderPropertiesNV;
struct DrawMeshTasksIndirectCommandNV;
//=== VK_NV_fragment_shader_barycentric ===
struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
//=== VK_NV_shader_image_footprint ===
struct PhysicalDeviceShaderImageFootprintFeaturesNV;
//=== VK_NV_scissor_exclusive ===
struct PipelineViewportExclusiveScissorStateCreateInfoNV;
struct PhysicalDeviceExclusiveScissorFeaturesNV;
//=== VK_NV_device_diagnostic_checkpoints ===
struct QueueFamilyCheckpointPropertiesNV;
struct CheckpointDataNV;
//=== VK_INTEL_shader_integer_functions2 ===
struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
//=== VK_INTEL_performance_query ===
union PerformanceValueDataINTEL;
struct PerformanceValueINTEL;
struct InitializePerformanceApiInfoINTEL;
struct QueryPoolPerformanceQueryCreateInfoINTEL;
using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
struct PerformanceMarkerInfoINTEL;
struct PerformanceStreamMarkerInfoINTEL;
struct PerformanceOverrideInfoINTEL;
struct PerformanceConfigurationAcquireInfoINTEL;
//=== VK_EXT_pci_bus_info ===
struct PhysicalDevicePCIBusInfoPropertiesEXT;
//=== VK_AMD_display_native_hdr ===
struct DisplayNativeHdrSurfaceCapabilitiesAMD;
struct SwapchainDisplayNativeHdrCreateInfoAMD;
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_imagepipe_surface ===
struct ImagePipeSurfaceCreateInfoFUCHSIA;
#endif /*VK_USE_PLATFORM_FUCHSIA*/
//=== VK_KHR_shader_terminate_invocation ===
struct PhysicalDeviceShaderTerminateInvocationFeaturesKHR;
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_surface ===
struct MetalSurfaceCreateInfoEXT;
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map ===
struct PhysicalDeviceFragmentDensityMapFeaturesEXT;
struct PhysicalDeviceFragmentDensityMapPropertiesEXT;
struct RenderPassFragmentDensityMapCreateInfoEXT;
//=== VK_EXT_subgroup_size_control ===
struct PhysicalDeviceSubgroupSizeControlFeaturesEXT;
struct PhysicalDeviceSubgroupSizeControlPropertiesEXT;
struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
//=== VK_KHR_fragment_shading_rate ===
struct FragmentShadingRateAttachmentInfoKHR;
struct PipelineFragmentShadingRateStateCreateInfoKHR;
struct PhysicalDeviceFragmentShadingRateFeaturesKHR;
struct PhysicalDeviceFragmentShadingRatePropertiesKHR;
struct PhysicalDeviceFragmentShadingRateKHR;
//=== VK_AMD_shader_core_properties2 ===
struct PhysicalDeviceShaderCoreProperties2AMD;
//=== VK_AMD_device_coherent_memory ===
struct PhysicalDeviceCoherentMemoryFeaturesAMD;
//=== VK_EXT_shader_image_atomic_int64 ===
struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
//=== VK_EXT_memory_budget ===
struct PhysicalDeviceMemoryBudgetPropertiesEXT;
//=== VK_EXT_memory_priority ===
struct PhysicalDeviceMemoryPriorityFeaturesEXT;
struct MemoryPriorityAllocateInfoEXT;
//=== VK_KHR_surface_protected_capabilities ===
struct SurfaceProtectedCapabilitiesKHR;
//=== VK_NV_dedicated_allocation_image_aliasing ===
struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
//=== VK_EXT_buffer_device_address ===
struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;
using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
struct BufferDeviceAddressCreateInfoEXT;
//=== VK_EXT_tooling_info ===
struct PhysicalDeviceToolPropertiesEXT;
//=== VK_EXT_validation_features ===
struct ValidationFeaturesEXT;
//=== VK_KHR_present_wait ===
struct PhysicalDevicePresentWaitFeaturesKHR;
//=== VK_NV_cooperative_matrix ===
struct CooperativeMatrixPropertiesNV;
struct PhysicalDeviceCooperativeMatrixFeaturesNV;
struct PhysicalDeviceCooperativeMatrixPropertiesNV;
//=== VK_NV_coverage_reduction_mode ===
struct PhysicalDeviceCoverageReductionModeFeaturesNV;
struct PipelineCoverageReductionStateCreateInfoNV;
struct FramebufferMixedSamplesCombinationNV;
//=== VK_EXT_fragment_shader_interlock ===
struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
//=== VK_EXT_ycbcr_image_arrays ===
struct PhysicalDeviceYcbcrImageArraysFeaturesEXT;
//=== VK_EXT_provoking_vertex ===
struct PhysicalDeviceProvokingVertexFeaturesEXT;
struct PhysicalDeviceProvokingVertexPropertiesEXT;
struct PipelineRasterizationProvokingVertexStateCreateInfoEXT;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_EXT_full_screen_exclusive ===
struct SurfaceFullScreenExclusiveInfoEXT;
struct SurfaceCapabilitiesFullScreenExclusiveEXT;
struct SurfaceFullScreenExclusiveWin32InfoEXT;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_headless_surface ===
struct HeadlessSurfaceCreateInfoEXT;
//=== VK_EXT_line_rasterization ===
struct PhysicalDeviceLineRasterizationFeaturesEXT;
struct PhysicalDeviceLineRasterizationPropertiesEXT;
struct PipelineRasterizationLineStateCreateInfoEXT;
//=== VK_EXT_shader_atomic_float ===
struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;
//=== VK_EXT_index_type_uint8 ===
struct PhysicalDeviceIndexTypeUint8FeaturesEXT;
//=== VK_EXT_extended_dynamic_state ===
struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;
//=== VK_KHR_pipeline_executable_properties ===
struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
struct PipelineInfoKHR;
struct PipelineExecutablePropertiesKHR;
struct PipelineExecutableInfoKHR;
union PipelineExecutableStatisticValueKHR;
struct PipelineExecutableStatisticKHR;
struct PipelineExecutableInternalRepresentationKHR;
//=== VK_EXT_shader_atomic_float2 ===
struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
//=== VK_EXT_shader_demote_to_helper_invocation ===
struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
//=== VK_NV_device_generated_commands ===
struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
struct GraphicsShaderGroupCreateInfoNV;
struct GraphicsPipelineShaderGroupsCreateInfoNV;
struct BindShaderGroupIndirectCommandNV;
struct BindIndexBufferIndirectCommandNV;
struct BindVertexBufferIndirectCommandNV;
struct SetStateFlagsIndirectCommandNV;
struct IndirectCommandsStreamNV;
struct IndirectCommandsLayoutTokenNV;
struct IndirectCommandsLayoutCreateInfoNV;
struct GeneratedCommandsInfoNV;
struct GeneratedCommandsMemoryRequirementsInfoNV;
//=== VK_NV_inherited_viewport_scissor ===
struct PhysicalDeviceInheritedViewportScissorFeaturesNV;
struct CommandBufferInheritanceViewportScissorInfoNV;
//=== VK_KHR_shader_integer_dot_product ===
struct PhysicalDeviceShaderIntegerDotProductFeaturesKHR;
struct PhysicalDeviceShaderIntegerDotProductPropertiesKHR;
//=== VK_EXT_texel_buffer_alignment ===
struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
//=== VK_QCOM_render_pass_transform ===
struct RenderPassTransformBeginInfoQCOM;
struct CommandBufferInheritanceRenderPassTransformInfoQCOM;
//=== VK_EXT_device_memory_report ===
struct PhysicalDeviceDeviceMemoryReportFeaturesEXT;
struct DeviceDeviceMemoryReportCreateInfoEXT;
struct DeviceMemoryReportCallbackDataEXT;
//=== VK_EXT_robustness2 ===
struct PhysicalDeviceRobustness2FeaturesEXT;
struct PhysicalDeviceRobustness2PropertiesEXT;
//=== VK_EXT_custom_border_color ===
struct SamplerCustomBorderColorCreateInfoEXT;
struct PhysicalDeviceCustomBorderColorPropertiesEXT;
struct PhysicalDeviceCustomBorderColorFeaturesEXT;
//=== VK_KHR_pipeline_library ===
struct PipelineLibraryCreateInfoKHR;
//=== VK_KHR_present_id ===
struct PresentIdKHR;
struct PhysicalDevicePresentIdFeaturesKHR;
//=== VK_EXT_private_data ===
struct PhysicalDevicePrivateDataFeaturesEXT;
struct DevicePrivateDataCreateInfoEXT;
struct PrivateDataSlotCreateInfoEXT;
//=== VK_EXT_pipeline_creation_cache_control ===
struct PhysicalDevicePipelineCreationCacheControlFeaturesEXT;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_video_encode_queue ===
struct VideoEncodeInfoKHR;
struct VideoEncodeRateControlInfoKHR;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_NV_device_diagnostics_config ===
struct PhysicalDeviceDiagnosticsConfigFeaturesNV;
struct DeviceDiagnosticsConfigCreateInfoNV;
//=== VK_KHR_synchronization2 ===
struct MemoryBarrier2KHR;
struct BufferMemoryBarrier2KHR;
struct ImageMemoryBarrier2KHR;
struct DependencyInfoKHR;
struct SubmitInfo2KHR;
struct SemaphoreSubmitInfoKHR;
struct CommandBufferSubmitInfoKHR;
struct PhysicalDeviceSynchronization2FeaturesKHR;
struct QueueFamilyCheckpointProperties2NV;
struct CheckpointData2NV;
//=== VK_KHR_shader_subgroup_uniform_control_flow ===
struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
//=== VK_KHR_zero_initialize_workgroup_memory ===
struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
//=== VK_NV_fragment_shading_rate_enums ===
struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
struct PipelineFragmentShadingRateEnumStateCreateInfoNV;
//=== VK_NV_ray_tracing_motion_blur ===
struct AccelerationStructureGeometryMotionTrianglesDataNV;
struct AccelerationStructureMotionInfoNV;
struct AccelerationStructureMotionInstanceNV;
union AccelerationStructureMotionInstanceDataNV;
struct AccelerationStructureMatrixMotionInstanceNV;
struct AccelerationStructureSRTMotionInstanceNV;
struct SRTDataNV;
struct PhysicalDeviceRayTracingMotionBlurFeaturesNV;
//=== VK_EXT_ycbcr_2plane_444_formats ===
struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
//=== VK_EXT_fragment_density_map2 ===
struct PhysicalDeviceFragmentDensityMap2FeaturesEXT;
struct PhysicalDeviceFragmentDensityMap2PropertiesEXT;
//=== VK_QCOM_rotated_copy_commands ===
struct CopyCommandTransformInfoQCOM;
//=== VK_EXT_image_robustness ===
struct PhysicalDeviceImageRobustnessFeaturesEXT;
//=== VK_KHR_workgroup_memory_explicit_layout ===
struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
//=== VK_KHR_copy_commands2 ===
struct CopyBufferInfo2KHR;
struct CopyImageInfo2KHR;
struct CopyBufferToImageInfo2KHR;
struct CopyImageToBufferInfo2KHR;
struct BlitImageInfo2KHR;
struct ResolveImageInfo2KHR;
struct BufferCopy2KHR;
struct ImageCopy2KHR;
struct ImageBlit2KHR;
struct BufferImageCopy2KHR;
struct ImageResolve2KHR;
//=== VK_EXT_4444_formats ===
struct PhysicalDevice4444FormatsFeaturesEXT;
#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
//=== VK_EXT_directfb_surface ===
struct DirectFBSurfaceCreateInfoEXT;
#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
//=== VK_KHR_ray_tracing_pipeline ===
struct RayTracingShaderGroupCreateInfoKHR;
struct RayTracingPipelineCreateInfoKHR;
struct PhysicalDeviceRayTracingPipelineFeaturesKHR;
struct PhysicalDeviceRayTracingPipelinePropertiesKHR;
struct StridedDeviceAddressRegionKHR;
struct TraceRaysIndirectCommandKHR;
struct RayTracingPipelineInterfaceCreateInfoKHR;
//=== VK_KHR_ray_query ===
struct PhysicalDeviceRayQueryFeaturesKHR;
//=== VK_VALVE_mutable_descriptor_type ===
struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
struct MutableDescriptorTypeListVALVE;
struct MutableDescriptorTypeCreateInfoVALVE;
//=== VK_EXT_vertex_input_dynamic_state ===
struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
struct VertexInputBindingDescription2EXT;
struct VertexInputAttributeDescription2EXT;
//=== VK_EXT_physical_device_drm ===
struct PhysicalDeviceDrmPropertiesEXT;
//=== VK_EXT_primitive_topology_list_restart ===
struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_external_memory ===
struct ImportMemoryZirconHandleInfoFUCHSIA;
struct MemoryZirconHandlePropertiesFUCHSIA;
struct MemoryGetZirconHandleInfoFUCHSIA;
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_external_semaphore ===
struct ImportSemaphoreZirconHandleInfoFUCHSIA;
struct SemaphoreGetZirconHandleInfoFUCHSIA;
#endif /*VK_USE_PLATFORM_FUCHSIA*/
//=== VK_HUAWEI_subpass_shading ===
struct SubpassShadingPipelineCreateInfoHUAWEI;
struct PhysicalDeviceSubpassShadingFeaturesHUAWEI;
struct PhysicalDeviceSubpassShadingPropertiesHUAWEI;
//=== VK_HUAWEI_invocation_mask ===
struct PhysicalDeviceInvocationMaskFeaturesHUAWEI;
//=== VK_NV_external_memory_rdma ===
struct MemoryGetRemoteAddressInfoNV;
struct PhysicalDeviceExternalMemoryRDMAFeaturesNV;
//=== VK_EXT_extended_dynamic_state2 ===
struct PhysicalDeviceExtendedDynamicState2FeaturesEXT;
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_screen_surface ===
struct ScreenSurfaceCreateInfoQNX;
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
//=== VK_EXT_color_write_enable ===
struct PhysicalDeviceColorWriteEnableFeaturesEXT;
struct PipelineColorWriteCreateInfoEXT;
//=== VK_EXT_global_priority_query ===
struct PhysicalDeviceGlobalPriorityQueryFeaturesEXT;
struct QueueFamilyGlobalPriorityPropertiesEXT;
//=== VK_EXT_multi_draw ===
struct PhysicalDeviceMultiDrawFeaturesEXT;
struct PhysicalDeviceMultiDrawPropertiesEXT;
struct MultiDrawInfoEXT;
struct MultiDrawIndexedInfoEXT;
//=== VK_EXT_pageable_device_local_memory ===
struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
//===============
//=== HANDLEs ===
//===============
class SurfaceKHR
{
public:
using CType = VkSurfaceKHR;
using NativeType = VkSurfaceKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;
public:
VULKAN_HPP_CONSTEXPR SurfaceKHR() = default;
VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT
{
m_surfaceKHR = surfaceKHR;
return *this;
}
#endif
SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_surfaceKHR = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SurfaceKHR const & ) const = default;
#else
bool operator==( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_surfaceKHR == rhs.m_surfaceKHR;
}
bool operator!=( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_surfaceKHR != rhs.m_surfaceKHR;
}
bool operator<( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_surfaceKHR < rhs.m_surfaceKHR;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT
{
return m_surfaceKHR;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_surfaceKHR != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_surfaceKHR == VK_NULL_HANDLE;
}
private:
VkSurfaceKHR m_surfaceKHR = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceKHR ) == sizeof( VkSurfaceKHR ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SurfaceKHR>::value,
"SurfaceKHR is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSurfaceKHR>
{
using type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR>
{
using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR>
{
using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SurfaceKHR>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class DebugReportCallbackEXT
{
public:
using CType = VkDebugReportCallbackEXT;
using NativeType = VkDebugReportCallbackEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;
public:
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() = default;
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT
DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
: m_debugReportCallbackEXT( debugReportCallbackEXT )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
{
m_debugReportCallbackEXT = debugReportCallbackEXT;
return *this;
}
#endif
DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_debugReportCallbackEXT = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DebugReportCallbackEXT const & ) const = default;
#else
bool operator==( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
}
bool operator!=( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
}
bool operator<( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT
{
return m_debugReportCallbackEXT;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_debugReportCallbackEXT != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_debugReportCallbackEXT == VK_NULL_HANDLE;
}
private:
VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT ) ==
sizeof( VkDebugReportCallbackEXT ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::value,
"DebugReportCallbackEXT is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDebugReportCallbackEXT>
{
using type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT>
{
using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT>
{
using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class DebugUtilsMessengerEXT
{
public:
using CType = VkDebugUtilsMessengerEXT;
using NativeType = VkDebugUtilsMessengerEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
public:
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() = default;
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT
DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
: m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
{
m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
return *this;
}
#endif
DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_debugUtilsMessengerEXT = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DebugUtilsMessengerEXT const & ) const = default;
#else
bool operator==( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
}
bool operator!=( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
}
bool operator<( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
{
return m_debugUtilsMessengerEXT;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
}
private:
VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT ) ==
sizeof( VkDebugUtilsMessengerEXT ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::value,
"DebugUtilsMessengerEXT is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDebugUtilsMessengerEXT>
{
using type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT>
{
using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class DisplayKHR
{
public:
using CType = VkDisplayKHR;
using NativeType = VkDisplayKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
public:
VULKAN_HPP_CONSTEXPR DisplayKHR() = default;
VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
{
m_displayKHR = displayKHR;
return *this;
}
#endif
DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_displayKHR = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayKHR const & ) const = default;
#else
bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_displayKHR == rhs.m_displayKHR;
}
bool operator!=( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_displayKHR != rhs.m_displayKHR;
}
bool operator<( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_displayKHR < rhs.m_displayKHR;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT
{
return m_displayKHR;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_displayKHR != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_displayKHR == VK_NULL_HANDLE;
}
private:
VkDisplayKHR m_displayKHR = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayKHR ) == sizeof( VkDisplayKHR ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayKHR>::value,
"DisplayKHR is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDisplayKHR>
{
using type = VULKAN_HPP_NAMESPACE::DisplayKHR;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>
{
using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>
{
using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class SwapchainKHR
{
public:
using CType = VkSwapchainKHR;
using NativeType = VkSwapchainKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;
public:
VULKAN_HPP_CONSTEXPR SwapchainKHR() = default;
VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
: m_swapchainKHR( swapchainKHR )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
{
m_swapchainKHR = swapchainKHR;
return *this;
}
#endif
SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_swapchainKHR = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SwapchainKHR const & ) const = default;
#else
bool operator==( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_swapchainKHR == rhs.m_swapchainKHR;
}
bool operator!=( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_swapchainKHR != rhs.m_swapchainKHR;
}
bool operator<( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_swapchainKHR < rhs.m_swapchainKHR;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT
{
return m_swapchainKHR;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_swapchainKHR != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_swapchainKHR == VK_NULL_HANDLE;
}
private:
VkSwapchainKHR m_swapchainKHR = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainKHR ) == sizeof( VkSwapchainKHR ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SwapchainKHR>::value,
"SwapchainKHR is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSwapchainKHR>
{
using type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR>
{
using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR>
{
using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SwapchainKHR>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class Semaphore
{
public:
using CType = VkSemaphore;
using NativeType = VkSemaphore;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;
public:
VULKAN_HPP_CONSTEXPR Semaphore() = default;
VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT
{
m_semaphore = semaphore;
return *this;
}
#endif
Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_semaphore = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Semaphore const & ) const = default;
#else
bool operator==( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_semaphore == rhs.m_semaphore;
}
bool operator!=( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_semaphore != rhs.m_semaphore;
}
bool operator<( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_semaphore < rhs.m_semaphore;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT
{
return m_semaphore;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_semaphore != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_semaphore == VK_NULL_HANDLE;
}
private:
VkSemaphore m_semaphore = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Semaphore ) == sizeof( VkSemaphore ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Semaphore>::value,
"Semaphore is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSemaphore>
{
using type = VULKAN_HPP_NAMESPACE::Semaphore;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore>
{
using Type = VULKAN_HPP_NAMESPACE::Semaphore;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore>
{
using Type = VULKAN_HPP_NAMESPACE::Semaphore;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Semaphore>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class Fence
{
public:
using CType = VkFence;
using NativeType = VkFence;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eFence;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;
public:
VULKAN_HPP_CONSTEXPR Fence() = default;
VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT
{
m_fence = fence;
return *this;
}
#endif
Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_fence = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Fence const & ) const = default;
#else
bool operator==( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_fence == rhs.m_fence;
}
bool operator!=( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_fence != rhs.m_fence;
}
bool operator<( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_fence < rhs.m_fence;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT
{
return m_fence;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_fence != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_fence == VK_NULL_HANDLE;
}
private:
VkFence m_fence = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Fence ) == sizeof( VkFence ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Fence>::value,
"Fence is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eFence>
{
using type = VULKAN_HPP_NAMESPACE::Fence;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFence>
{
using Type = VULKAN_HPP_NAMESPACE::Fence;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence>
{
using Type = VULKAN_HPP_NAMESPACE::Fence;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Fence>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class PerformanceConfigurationINTEL
{
public:
using CType = VkPerformanceConfigurationINTEL;
using NativeType = VkPerformanceConfigurationINTEL;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
public:
VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL() = default;
VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT
PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
: m_performanceConfigurationINTEL( performanceConfigurationINTEL )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
PerformanceConfigurationINTEL &
operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
{
m_performanceConfigurationINTEL = performanceConfigurationINTEL;
return *this;
}
#endif
PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_performanceConfigurationINTEL = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PerformanceConfigurationINTEL const & ) const = default;
#else
bool operator==( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_performanceConfigurationINTEL == rhs.m_performanceConfigurationINTEL;
}
bool operator!=( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_performanceConfigurationINTEL != rhs.m_performanceConfigurationINTEL;
}
bool operator<( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_performanceConfigurationINTEL < rhs.m_performanceConfigurationINTEL;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT
{
return m_performanceConfigurationINTEL;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_performanceConfigurationINTEL != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_performanceConfigurationINTEL == VK_NULL_HANDLE;
}
private:
VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL ) ==
sizeof( VkPerformanceConfigurationINTEL ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT(
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::value,
"PerformanceConfigurationINTEL is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePerformanceConfigurationINTEL>
{
using type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL>
{
using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class QueryPool
{
public:
using CType = VkQueryPool;
using NativeType = VkQueryPool;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;
public:
VULKAN_HPP_CONSTEXPR QueryPool() = default;
VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT
{
m_queryPool = queryPool;
return *this;
}
#endif
QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_queryPool = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( QueryPool const & ) const = default;
#else
bool operator==( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_queryPool == rhs.m_queryPool;
}
bool operator!=( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_queryPool != rhs.m_queryPool;
}
bool operator<( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_queryPool < rhs.m_queryPool;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT
{
return m_queryPool;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_queryPool != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_queryPool == VK_NULL_HANDLE;
}
private:
VkQueryPool m_queryPool = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryPool ) == sizeof( VkQueryPool ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::QueryPool>::value,
"QueryPool is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eQueryPool>
{
using type = VULKAN_HPP_NAMESPACE::QueryPool;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool>
{
using Type = VULKAN_HPP_NAMESPACE::QueryPool;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool>
{
using Type = VULKAN_HPP_NAMESPACE::QueryPool;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::QueryPool>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class Buffer
{
public:
using CType = VkBuffer;
using NativeType = VkBuffer;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;
public:
VULKAN_HPP_CONSTEXPR Buffer() = default;
VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
Buffer & operator=( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT
{
m_buffer = buffer;
return *this;
}
#endif
Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_buffer = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Buffer const & ) const = default;
#else
bool operator==( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_buffer == rhs.m_buffer;
}
bool operator!=( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_buffer != rhs.m_buffer;
}
bool operator<( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_buffer < rhs.m_buffer;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT
{
return m_buffer;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_buffer != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_buffer == VK_NULL_HANDLE;
}
private:
VkBuffer m_buffer = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Buffer ) == sizeof( VkBuffer ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Buffer>::value,
"Buffer is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eBuffer>
{
using type = VULKAN_HPP_NAMESPACE::Buffer;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBuffer>
{
using Type = VULKAN_HPP_NAMESPACE::Buffer;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer>
{
using Type = VULKAN_HPP_NAMESPACE::Buffer;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Buffer>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class PipelineLayout
{
public:
using CType = VkPipelineLayout;
using NativeType = VkPipelineLayout;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;
public:
VULKAN_HPP_CONSTEXPR PipelineLayout() = default;
VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
: m_pipelineLayout( pipelineLayout )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
{
m_pipelineLayout = pipelineLayout;
return *this;
}
#endif
PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_pipelineLayout = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineLayout const & ) const = default;
#else
bool operator==( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_pipelineLayout == rhs.m_pipelineLayout;
}
bool operator!=( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_pipelineLayout != rhs.m_pipelineLayout;
}
bool operator<( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_pipelineLayout < rhs.m_pipelineLayout;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT
{
return m_pipelineLayout;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_pipelineLayout != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_pipelineLayout == VK_NULL_HANDLE;
}
private:
VkPipelineLayout m_pipelineLayout = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineLayout ) == sizeof( VkPipelineLayout ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineLayout>::value,
"PipelineLayout is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePipelineLayout>
{
using type = VULKAN_HPP_NAMESPACE::PipelineLayout;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout>
{
using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout>
{
using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineLayout>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class DescriptorSet
{
public:
using CType = VkDescriptorSet;
using NativeType = VkDescriptorSet;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;
public:
VULKAN_HPP_CONSTEXPR DescriptorSet() = default;
VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
: m_descriptorSet( descriptorSet )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
{
m_descriptorSet = descriptorSet;
return *this;
}
#endif
DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_descriptorSet = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorSet const & ) const = default;
#else
bool operator==( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_descriptorSet == rhs.m_descriptorSet;
}
bool operator!=( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_descriptorSet != rhs.m_descriptorSet;
}
bool operator<( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_descriptorSet < rhs.m_descriptorSet;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT
{
return m_descriptorSet;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_descriptorSet != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_descriptorSet == VK_NULL_HANDLE;
}
private:
VkDescriptorSet m_descriptorSet = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSet ) == sizeof( VkDescriptorSet ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorSet>::value,
"DescriptorSet is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorSet>
{
using type = VULKAN_HPP_NAMESPACE::DescriptorSet;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet>
{
using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet>
{
using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSet>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class ImageView
{
public:
using CType = VkImageView;
using NativeType = VkImageView;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eImageView;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;
public:
VULKAN_HPP_CONSTEXPR ImageView() = default;
VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT
{
m_imageView = imageView;
return *this;
}
#endif
ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_imageView = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ImageView const & ) const = default;
#else
bool operator==( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_imageView == rhs.m_imageView;
}
bool operator!=( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_imageView != rhs.m_imageView;
}
bool operator<( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_imageView < rhs.m_imageView;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT
{
return m_imageView;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_imageView != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_imageView == VK_NULL_HANDLE;
}
private:
VkImageView m_imageView = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageView ) == sizeof( VkImageView ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageView>::value,
"ImageView is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eImageView>
{
using type = VULKAN_HPP_NAMESPACE::ImageView;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImageView>
{
using Type = VULKAN_HPP_NAMESPACE::ImageView;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView>
{
using Type = VULKAN_HPP_NAMESPACE::ImageView;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ImageView>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class Pipeline
{
public:
using CType = VkPipeline;
using NativeType = VkPipeline;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;
public:
VULKAN_HPP_CONSTEXPR Pipeline() = default;
VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT
{
m_pipeline = pipeline;
return *this;
}
#endif
Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_pipeline = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Pipeline const & ) const = default;
#else
bool operator==( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_pipeline == rhs.m_pipeline;
}
bool operator!=( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_pipeline != rhs.m_pipeline;
}
bool operator<( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_pipeline < rhs.m_pipeline;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT
{
return m_pipeline;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_pipeline != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_pipeline == VK_NULL_HANDLE;
}
private:
VkPipeline m_pipeline = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Pipeline ) == sizeof( VkPipeline ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Pipeline>::value,
"Pipeline is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePipeline>
{
using type = VULKAN_HPP_NAMESPACE::Pipeline;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipeline>
{
using Type = VULKAN_HPP_NAMESPACE::Pipeline;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline>
{
using Type = VULKAN_HPP_NAMESPACE::Pipeline;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Pipeline>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class Image
{
public:
using CType = VkImage;
using NativeType = VkImage;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eImage;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;
public:
VULKAN_HPP_CONSTEXPR Image() = default;
VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT
{
m_image = image;
return *this;
}
#endif
Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_image = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Image const & ) const = default;
#else
bool operator==( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_image == rhs.m_image;
}
bool operator!=( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_image != rhs.m_image;
}
bool operator<( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_image < rhs.m_image;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT
{
return m_image;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_image != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_image == VK_NULL_HANDLE;
}
private:
VkImage m_image = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Image ) == sizeof( VkImage ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Image>::value,
"Image is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eImage>
{
using type = VULKAN_HPP_NAMESPACE::Image;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImage>
{
using Type = VULKAN_HPP_NAMESPACE::Image;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage>
{
using Type = VULKAN_HPP_NAMESPACE::Image;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Image>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class AccelerationStructureNV
{
public:
using CType = VkAccelerationStructureNV;
using NativeType = VkAccelerationStructureNV;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;
public:
VULKAN_HPP_CONSTEXPR AccelerationStructureNV() = default;
VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT
AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
: m_accelerationStructureNV( accelerationStructureNV )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
{
m_accelerationStructureNV = accelerationStructureNV;
return *this;
}
#endif
AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_accelerationStructureNV = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AccelerationStructureNV const & ) const = default;
#else
bool operator==( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_accelerationStructureNV == rhs.m_accelerationStructureNV;
}
bool operator!=( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_accelerationStructureNV != rhs.m_accelerationStructureNV;
}
bool operator<( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_accelerationStructureNV < rhs.m_accelerationStructureNV;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT
{
return m_accelerationStructureNV;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_accelerationStructureNV != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_accelerationStructureNV == VK_NULL_HANDLE;
}
private:
VkAccelerationStructureNV m_accelerationStructureNV = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureNV ) ==
sizeof( VkAccelerationStructureNV ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::value,
"AccelerationStructureNV is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eAccelerationStructureNV>
{
using type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV>
{
using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV>
{
using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class DescriptorUpdateTemplate
{
public:
using CType = VkDescriptorUpdateTemplate;
using NativeType = VkDescriptorUpdateTemplate;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;
public:
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() = default;
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT
DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
: m_descriptorUpdateTemplate( descriptorUpdateTemplate )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
{
m_descriptorUpdateTemplate = descriptorUpdateTemplate;
return *this;
}
#endif
DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_descriptorUpdateTemplate = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorUpdateTemplate const & ) const = default;
#else
bool operator==( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;
}
bool operator!=( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;
}
bool operator<( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT
{
return m_descriptorUpdateTemplate;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
}
private:
VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate ) ==
sizeof( VkDescriptorUpdateTemplate ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::value,
"DescriptorUpdateTemplate is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorUpdateTemplate>
{
using type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate>
{
using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate>
{
using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
class Event
{
public:
using CType = VkEvent;
using NativeType = VkEvent;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eEvent;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;
public:
VULKAN_HPP_CONSTEXPR Event() = default;
VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
Event & operator=( VkEvent event ) VULKAN_HPP_NOEXCEPT
{
m_event = event;
return *this;
}
#endif
Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_event = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Event const & ) const = default;
#else
bool operator==( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_event == rhs.m_event;
}
bool operator!=( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_event != rhs.m_event;
}
bool operator<( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_event < rhs.m_event;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT
{
return m_event;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_event != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_event == VK_NULL_HANDLE;
}
private:
VkEvent m_event = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Event ) == sizeof( VkEvent ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Event>::value,
"Event is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eEvent>
{
using type = VULKAN_HPP_NAMESPACE::Event;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eEvent>
{
using Type = VULKAN_HPP_NAMESPACE::Event;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent>
{
using Type = VULKAN_HPP_NAMESPACE::Event;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Event>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class AccelerationStructureKHR
{
public:
using CType = VkAccelerationStructureKHR;
using NativeType = VkAccelerationStructureKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;
public:
VULKAN_HPP_CONSTEXPR AccelerationStructureKHR() = default;
VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT
AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
: m_accelerationStructureKHR( accelerationStructureKHR )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
{
m_accelerationStructureKHR = accelerationStructureKHR;
return *this;
}
#endif
AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_accelerationStructureKHR = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( AccelerationStructureKHR const & ) const = default;
#else
bool operator==( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_accelerationStructureKHR == rhs.m_accelerationStructureKHR;
}
bool operator!=( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_accelerationStructureKHR != rhs.m_accelerationStructureKHR;
}
bool operator<( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_accelerationStructureKHR < rhs.m_accelerationStructureKHR;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT
{
return m_accelerationStructureKHR;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_accelerationStructureKHR != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_accelerationStructureKHR == VK_NULL_HANDLE;
}
private:
VkAccelerationStructureKHR m_accelerationStructureKHR = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR ) ==
sizeof( VkAccelerationStructureKHR ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::value,
"AccelerationStructureKHR is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eAccelerationStructureKHR>
{
using type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR>
{
using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR>
{
using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class CommandBuffer
{
public:
using CType = VkCommandBuffer;
using NativeType = VkCommandBuffer;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;
public:
VULKAN_HPP_CONSTEXPR CommandBuffer() = default;
VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
: m_commandBuffer( commandBuffer )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
CommandBuffer & operator=( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
{
m_commandBuffer = commandBuffer;
return *this;
}
#endif
CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_commandBuffer = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CommandBuffer const & ) const = default;
#else
bool operator==( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_commandBuffer == rhs.m_commandBuffer;
}
bool operator!=( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_commandBuffer != rhs.m_commandBuffer;
}
bool operator<( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_commandBuffer < rhs.m_commandBuffer;
}
#endif
//=== VK_VERSION_1_0 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
begin( const CommandBufferBeginInfo & beginInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type
reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
VULKAN_HPP_NAMESPACE::Pipeline pipeline,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setViewport( uint32_t firstViewport,
uint32_t viewportCount,
const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setViewport( uint32_t firstViewport,
ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setScissor( uint32_t firstScissor,
uint32_t scissorCount,
const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setScissor( uint32_t firstScissor,
ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setLineWidth( float lineWidth,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setDepthBias( float depthBiasConstantFactor,
float depthBiasClamp,
float depthBiasSlopeFactor,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setBlendConstants( const float blendConstants[4],
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setDepthBounds( float minDepthBounds,
float maxDepthBounds,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
uint32_t compareMask,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
uint32_t writeMask,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
uint32_t reference,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
VULKAN_HPP_NAMESPACE::PipelineLayout layout,
uint32_t firstSet,
uint32_t descriptorSetCount,
const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
uint32_t dynamicOffsetCount,
const uint32_t * pDynamicOffsets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
VULKAN_HPP_NAMESPACE::PipelineLayout layout,
uint32_t firstSet,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
ArrayProxy<const uint32_t> const & dynamicOffsets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
VULKAN_HPP_NAMESPACE::IndexType indexType,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void bindVertexBuffers( uint32_t firstBinding,
uint32_t bindingCount,
const VULKAN_HPP_NAMESPACE::Buffer * pBuffers,
const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void bindVertexBuffers( uint32_t firstBinding,
ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void draw( uint32_t vertexCount,
uint32_t instanceCount,
uint32_t firstVertex,
uint32_t firstInstance,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawIndexed( uint32_t indexCount,
uint32_t instanceCount,
uint32_t firstIndex,
int32_t vertexOffset,
uint32_t firstInstance,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
uint32_t drawCount,
uint32_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
uint32_t drawCount,
uint32_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void dispatch( uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
uint32_t regionCount,
const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage,
VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
VULKAN_HPP_NAMESPACE::Image dstImage,
VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
uint32_t regionCount,
const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage,
VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
VULKAN_HPP_NAMESPACE::Image dstImage,
VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage,
VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
VULKAN_HPP_NAMESPACE::Image dstImage,
VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
uint32_t regionCount,
const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions,
VULKAN_HPP_NAMESPACE::Filter filter,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage,
VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
VULKAN_HPP_NAMESPACE::Image dstImage,
VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,
VULKAN_HPP_NAMESPACE::Filter filter,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
VULKAN_HPP_NAMESPACE::Image dstImage,
VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
uint32_t regionCount,
const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
VULKAN_HPP_NAMESPACE::Image dstImage,
VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage,
VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
uint32_t regionCount,
const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage,
VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
VULKAN_HPP_NAMESPACE::DeviceSize dataSize,
const void * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
ArrayProxy<const T> const & data,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
VULKAN_HPP_NAMESPACE::DeviceSize size,
uint32_t data,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void clearColorImage( VULKAN_HPP_NAMESPACE::Image image,
VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
const VULKAN_HPP_NAMESPACE::ClearColorValue * pColor,
uint32_t rangeCount,
const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void clearColorImage( VULKAN_HPP_NAMESPACE::Image image,
VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
const ClearColorValue & color,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image,
VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil,
uint32_t rangeCount,
const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image,
VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
const ClearDepthStencilValue & depthStencil,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void clearAttachments( uint32_t attachmentCount,
const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments,
uint32_t rectCount,
const VULKAN_HPP_NAMESPACE::ClearRect * pRects,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void clearAttachments( ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage,
VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
VULKAN_HPP_NAMESPACE::Image dstImage,
VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
uint32_t regionCount,
const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage,
VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
VULKAN_HPP_NAMESPACE::Image dstImage,
VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setEvent( VULKAN_HPP_NAMESPACE::Event event,
VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void resetEvent( VULKAN_HPP_NAMESPACE::Event event,
VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void waitEvents( uint32_t eventCount,
const VULKAN_HPP_NAMESPACE::Event * pEvents,
VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask,
VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask,
uint32_t memoryBarrierCount,
const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void waitEvents( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,
VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask,
VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask,
ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask,
VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask,
VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags,
uint32_t memoryBarrierCount,
const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask,
VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask,
VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags,
ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t query,
VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t query,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t query,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
VULKAN_HPP_NAMESPACE::DeviceSize stride,
VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout,
VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
uint32_t offset,
uint32_t size,
const void * pValues,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout,
VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
uint32_t offset,
ArrayProxy<const T> const & values,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
VULKAN_HPP_NAMESPACE::SubpassContents contents,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void beginRenderPass( const RenderPassBeginInfo & renderPassBegin,
VULKAN_HPP_NAMESPACE::SubpassContents contents,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void executeCommands( uint32_t commandBufferCount,
const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void executeCommands( ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_VERSION_1_1 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setDeviceMask( uint32_t deviceMask,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void dispatchBase( uint32_t baseGroupX,
uint32_t baseGroupY,
uint32_t baseGroupZ,
uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_VERSION_1_2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
VULKAN_HPP_NAMESPACE::Buffer countBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
VULKAN_HPP_NAMESPACE::Buffer countBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void beginRenderPass2( const RenderPassBeginInfo & renderPassBegin,
const SubpassBeginInfo & subpassBeginInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void nextSubpass2( const SubpassBeginInfo & subpassBeginInfo,
const SubpassEndInfo & subpassEndInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endRenderPass2( const SubpassEndInfo & subpassEndInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_debug_marker ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_video_queue ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_video_decode_queue ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pFrameInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void decodeVideoKHR( const VideoDecodeInfoKHR & frameInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_transform_feedback ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
uint32_t bindingCount,
const VULKAN_HPP_NAMESPACE::Buffer * pBuffers,
const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void bindTransformFeedbackBuffersEXT(
uint32_t firstBinding,
ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
uint32_t counterBufferCount,
const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers,
const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
endTransformFeedbackEXT( uint32_t firstCounterBuffer,
uint32_t counterBufferCount,
const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers,
const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endTransformFeedbackEXT( uint32_t firstCounterBuffer,
ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t query,
VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
uint32_t index,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t query,
uint32_t index,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
drawIndirectByteCountEXT( uint32_t instanceCount,
uint32_t firstInstance,
VULKAN_HPP_NAMESPACE::Buffer counterBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
uint32_t counterOffset,
uint32_t vertexStride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_NVX_binary_import ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_AMD_draw_indirect_count ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
VULKAN_HPP_NAMESPACE::Buffer countBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
VULKAN_HPP_NAMESPACE::Buffer countBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
//=== VK_KHR_device_group ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setDeviceMaskKHR( uint32_t deviceMask,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void dispatchBaseKHR( uint32_t baseGroupX,
uint32_t baseGroupY,
uint32_t baseGroupZ,
uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_KHR_push_descriptor ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
VULKAN_HPP_NAMESPACE::PipelineLayout layout,
uint32_t set,
uint32_t descriptorWriteCount,
const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
VULKAN_HPP_NAMESPACE::PipelineLayout layout,
uint32_t set,
ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
VULKAN_HPP_NAMESPACE::PipelineLayout layout,
uint32_t set,
const void * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_conditional_rendering ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void beginConditionalRenderingEXT(
const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
//=== VK_NV_clip_space_w_scaling ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setViewportWScalingNV( uint32_t firstViewport,
uint32_t viewportCount,
const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setViewportWScalingNV( uint32_t firstViewport,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_discard_rectangles ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
uint32_t discardRectangleCount,
const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_create_renderpass2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin,
const SubpassBeginInfo & subpassBeginInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo,
const SubpassEndInfo & subpassEndInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_debug_utils ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_sample_locations ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_acceleration_structure ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void buildAccelerationStructuresKHR(
uint32_t infoCount,
const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void buildAccelerationStructuresKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void buildAccelerationStructuresIndirectKHR(
uint32_t infoCount,
const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
const VULKAN_HPP_NAMESPACE::DeviceAddress * pIndirectDeviceAddresses,
const uint32_t * pIndirectStrides,
const uint32_t * const * ppMaxPrimitiveCounts,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void buildAccelerationStructuresIndirectKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses,
ArrayProxy<const uint32_t> const & indirectStrides,
ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyAccelerationStructureToMemoryKHR(
const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyMemoryToAccelerationStructureKHR(
const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void writeAccelerationStructuresPropertiesKHR(
uint32_t accelerationStructureCount,
const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
VULKAN_HPP_NAMESPACE::QueryType queryType,
VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void writeAccelerationStructuresPropertiesKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
VULKAN_HPP_NAMESPACE::QueryType queryType,
VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_NV_shading_rate_image ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView,
VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setViewportShadingRatePaletteNV( uint32_t firstViewport,
uint32_t viewportCount,
const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setViewportShadingRatePaletteNV(
uint32_t firstViewport,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType,
uint32_t customSampleOrderCount,
const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setCoarseSampleOrderNV(
VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType,
ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_NV_ray_tracing ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo,
VULKAN_HPP_NAMESPACE::Buffer instanceData,
VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset,
VULKAN_HPP_NAMESPACE::Bool32 update,
VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
VULKAN_HPP_NAMESPACE::Buffer scratch,
VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info,
VULKAN_HPP_NAMESPACE::Buffer instanceData,
VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset,
VULKAN_HPP_NAMESPACE::Bool32 update,
VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
VULKAN_HPP_NAMESPACE::Buffer scratch,
VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
uint32_t width,
uint32_t height,
uint32_t depth,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void writeAccelerationStructuresPropertiesNV(
uint32_t accelerationStructureCount,
const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures,
VULKAN_HPP_NAMESPACE::QueryType queryType,
VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void writeAccelerationStructuresPropertiesNV(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
VULKAN_HPP_NAMESPACE::QueryType queryType,
VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_draw_indirect_count ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
VULKAN_HPP_NAMESPACE::Buffer countBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
VULKAN_HPP_NAMESPACE::Buffer countBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
//=== VK_AMD_buffer_marker ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
uint32_t marker,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_NV_mesh_shader ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawMeshTasksNV( uint32_t taskCount,
uint32_t firstTask,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
uint32_t drawCount,
uint32_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
VULKAN_HPP_NAMESPACE::Buffer countBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
//=== VK_NV_scissor_exclusive ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setExclusiveScissorNV( uint32_t firstExclusiveScissor,
uint32_t exclusiveScissorCount,
const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setExclusiveScissorNV( uint32_t firstExclusiveScissor,
ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_NV_device_diagnostic_checkpoints ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setCheckpointNV( const void * pCheckpointMarker,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_INTEL_performance_query ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL(
const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL(
const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL(
const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_fragment_shading_rate ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D * pFragmentSize,
const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setFragmentShadingRateKHR( const Extent2D & fragmentSize,
const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_line_rasterization ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setLineStippleEXT( uint32_t lineStippleFactor,
uint16_t lineStipplePattern,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_extended_dynamic_state ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
setViewportWithCountEXT( uint32_t viewportCount,
const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
setViewportWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
setScissorWithCountEXT( uint32_t scissorCount,
const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
setScissorWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void bindVertexBuffers2EXT( uint32_t firstBinding,
uint32_t bindingCount,
const VULKAN_HPP_NAMESPACE::Buffer * pBuffers,
const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void bindVertexBuffers2EXT(
uint32_t firstBinding,
ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
VULKAN_HPP_NAMESPACE::StencilOp failOp,
VULKAN_HPP_NAMESPACE::StencilOp passOp,
VULKAN_HPP_NAMESPACE::StencilOp depthFailOp,
VULKAN_HPP_NAMESPACE::CompareOp compareOp,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_NV_device_generated_commands ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed,
const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed,
const GeneratedCommandsInfoNV & generatedCommandsInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t groupIndex,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_video_encode_queue ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_KHR_synchronization2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
const DependencyInfoKHR & dependencyInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void waitEvents2KHR( uint32_t eventCount,
const VULKAN_HPP_NAMESPACE::Event * pEvents,
const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void waitEvents2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfoKHR> const & dependencyInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void pipelineBarrier2KHR( const DependencyInfoKHR & dependencyInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t query,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
uint32_t marker,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_NV_fragment_shading_rate_enums ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate,
const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
//=== VK_KHR_copy_commands2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR * pCopyBufferInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyBuffer2KHR( const CopyBufferInfo2KHR & copyBufferInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR * pCopyImageInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyImage2KHR( const CopyImageInfo2KHR & copyImageInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR * pCopyBufferToImageInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyBufferToImage2KHR( const CopyBufferToImageInfo2KHR & copyBufferToImageInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR * pCopyImageToBufferInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyImageToBuffer2KHR( const CopyImageToBufferInfo2KHR & copyImageToBufferInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR * pBlitImageInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void blitImage2KHR( const BlitImageInfo2KHR & blitImageInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR * pResolveImageInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void resolveImage2KHR( const ResolveImageInfo2KHR & resolveImageInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_ray_tracing_pipeline ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
uint32_t width,
uint32_t height,
uint32_t depth,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
const StridedDeviceAddressRegionKHR & missShaderBindingTable,
const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
uint32_t width,
uint32_t height,
uint32_t depth,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
const StridedDeviceAddressRegionKHR & missShaderBindingTable,
const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_vertex_input_dynamic_state ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
setVertexInputEXT( uint32_t vertexBindingDescriptionCount,
const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT * pVertexBindingDescriptions,
uint32_t vertexAttributeDescriptionCount,
const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setVertexInputEXT(
ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions,
ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_HUAWEI_subpass_shading ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void subpassShadingHUAWEI( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_HUAWEI_invocation_mask ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView,
VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_extended_dynamic_state2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
setPatchControlPointsEXT( uint32_t patchControlPoints,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_color_write_enable ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
setColorWriteEnableEXT( uint32_t attachmentCount,
const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
setColorWriteEnableEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_multi_draw ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawMultiEXT( uint32_t drawCount,
const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo,
uint32_t instanceCount,
uint32_t firstInstance,
uint32_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawMultiEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo,
uint32_t instanceCount,
uint32_t firstInstance,
uint32_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawMultiIndexedEXT( uint32_t drawCount,
const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT * pIndexInfo,
uint32_t instanceCount,
uint32_t firstInstance,
uint32_t stride,
const int32_t * pVertexOffset,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawMultiIndexedEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo,
uint32_t instanceCount,
uint32_t firstInstance,
uint32_t stride,
Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
{
return m_commandBuffer;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_commandBuffer != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_commandBuffer == VK_NULL_HANDLE;
}
private:
VkCommandBuffer m_commandBuffer = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBuffer ) == sizeof( VkCommandBuffer ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CommandBuffer>::value,
"CommandBuffer is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCommandBuffer>
{
using type = VULKAN_HPP_NAMESPACE::CommandBuffer;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer>
{
using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer>
{
using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandBuffer>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class DeviceMemory
{
public:
using CType = VkDeviceMemory;
using NativeType = VkDeviceMemory;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;
public:
VULKAN_HPP_CONSTEXPR DeviceMemory() = default;
VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
: m_deviceMemory( deviceMemory )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
{
m_deviceMemory = deviceMemory;
return *this;
}
#endif
DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_deviceMemory = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceMemory const & ) const = default;
#else
bool operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_deviceMemory == rhs.m_deviceMemory;
}
bool operator!=( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_deviceMemory != rhs.m_deviceMemory;
}
bool operator<( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_deviceMemory < rhs.m_deviceMemory;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT
{
return m_deviceMemory;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_deviceMemory != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_deviceMemory == VK_NULL_HANDLE;
}
private:
VkDeviceMemory m_deviceMemory = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemory ) == sizeof( VkDeviceMemory ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceMemory>::value,
"DeviceMemory is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDeviceMemory>
{
using type = VULKAN_HPP_NAMESPACE::DeviceMemory;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory>
{
using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory>
{
using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeviceMemory>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
#if defined( VK_ENABLE_BETA_EXTENSIONS )
class VideoSessionKHR
{
public:
using CType = VkVideoSessionKHR;
using NativeType = VkVideoSessionKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
public:
VULKAN_HPP_CONSTEXPR VideoSessionKHR() = default;
VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
: m_videoSessionKHR( videoSessionKHR )
{}
# if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
{
m_videoSessionKHR = videoSessionKHR;
return *this;
}
# endif
VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_videoSessionKHR = {};
return *this;
}
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoSessionKHR const & ) const = default;
# else
bool operator==( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_videoSessionKHR == rhs.m_videoSessionKHR;
}
bool operator!=( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_videoSessionKHR != rhs.m_videoSessionKHR;
}
bool operator<( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_videoSessionKHR < rhs.m_videoSessionKHR;
}
# endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT
{
return m_videoSessionKHR;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_videoSessionKHR != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_videoSessionKHR == VK_NULL_HANDLE;
}
private:
VkVideoSessionKHR m_videoSessionKHR = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionKHR ) == sizeof( VkVideoSessionKHR ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::value,
"VideoSessionKHR is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eVideoSessionKHR>
{
using type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR>
{
using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
class DeferredOperationKHR
{
public:
using CType = VkDeferredOperationKHR;
using NativeType = VkDeferredOperationKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
public:
VULKAN_HPP_CONSTEXPR DeferredOperationKHR() = default;
VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
: m_deferredOperationKHR( deferredOperationKHR )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
{
m_deferredOperationKHR = deferredOperationKHR;
return *this;
}
#endif
DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_deferredOperationKHR = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeferredOperationKHR const & ) const = default;
#else
bool operator==( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_deferredOperationKHR == rhs.m_deferredOperationKHR;
}
bool operator!=( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_deferredOperationKHR != rhs.m_deferredOperationKHR;
}
bool operator<( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_deferredOperationKHR < rhs.m_deferredOperationKHR;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT
{
return m_deferredOperationKHR;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_deferredOperationKHR != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_deferredOperationKHR == VK_NULL_HANDLE;
}
private:
VkDeferredOperationKHR m_deferredOperationKHR = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeferredOperationKHR ) == sizeof( VkDeferredOperationKHR ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::value,
"DeferredOperationKHR is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDeferredOperationKHR>
{
using type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR>
{
using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class BufferView
{
public:
using CType = VkBufferView;
using NativeType = VkBufferView;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;
public:
VULKAN_HPP_CONSTEXPR BufferView() = default;
VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT
{
m_bufferView = bufferView;
return *this;
}
#endif
BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_bufferView = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( BufferView const & ) const = default;
#else
bool operator==( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_bufferView == rhs.m_bufferView;
}
bool operator!=( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_bufferView != rhs.m_bufferView;
}
bool operator<( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_bufferView < rhs.m_bufferView;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT
{
return m_bufferView;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_bufferView != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_bufferView == VK_NULL_HANDLE;
}
private:
VkBufferView m_bufferView = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferView ) == sizeof( VkBufferView ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BufferView>::value,
"BufferView is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eBufferView>
{
using type = VULKAN_HPP_NAMESPACE::BufferView;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferView>
{
using Type = VULKAN_HPP_NAMESPACE::BufferView;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView>
{
using Type = VULKAN_HPP_NAMESPACE::BufferView;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferView>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class CommandPool
{
public:
using CType = VkCommandPool;
using NativeType = VkCommandPool;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;
public:
VULKAN_HPP_CONSTEXPR CommandPool() = default;
VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
: m_commandPool( commandPool )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
{
m_commandPool = commandPool;
return *this;
}
#endif
CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_commandPool = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CommandPool const & ) const = default;
#else
bool operator==( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_commandPool == rhs.m_commandPool;
}
bool operator!=( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_commandPool != rhs.m_commandPool;
}
bool operator<( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_commandPool < rhs.m_commandPool;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT
{
return m_commandPool;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_commandPool != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_commandPool == VK_NULL_HANDLE;
}
private:
VkCommandPool m_commandPool = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandPool ) == sizeof( VkCommandPool ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CommandPool>::value,
"CommandPool is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCommandPool>
{
using type = VULKAN_HPP_NAMESPACE::CommandPool;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool>
{
using Type = VULKAN_HPP_NAMESPACE::CommandPool;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool>
{
using Type = VULKAN_HPP_NAMESPACE::CommandPool;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandPool>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class PipelineCache
{
public:
using CType = VkPipelineCache;
using NativeType = VkPipelineCache;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;
public:
VULKAN_HPP_CONSTEXPR PipelineCache() = default;
VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
: m_pipelineCache( pipelineCache )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
{
m_pipelineCache = pipelineCache;
return *this;
}
#endif
PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_pipelineCache = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PipelineCache const & ) const = default;
#else
bool operator==( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_pipelineCache == rhs.m_pipelineCache;
}
bool operator!=( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_pipelineCache != rhs.m_pipelineCache;
}
bool operator<( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_pipelineCache < rhs.m_pipelineCache;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT
{
return m_pipelineCache;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_pipelineCache != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_pipelineCache == VK_NULL_HANDLE;
}
private:
VkPipelineCache m_pipelineCache = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCache ) == sizeof( VkPipelineCache ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCache>::value,
"PipelineCache is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePipelineCache>
{
using type = VULKAN_HPP_NAMESPACE::PipelineCache;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache>
{
using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache>
{
using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineCache>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class CuFunctionNVX
{
public:
using CType = VkCuFunctionNVX;
using NativeType = VkCuFunctionNVX;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;
public:
VULKAN_HPP_CONSTEXPR CuFunctionNVX() = default;
VULKAN_HPP_CONSTEXPR CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
: m_cuFunctionNVX( cuFunctionNVX )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
{
m_cuFunctionNVX = cuFunctionNVX;
return *this;
}
#endif
CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_cuFunctionNVX = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CuFunctionNVX const & ) const = default;
#else
bool operator==( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_cuFunctionNVX == rhs.m_cuFunctionNVX;
}
bool operator!=( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_cuFunctionNVX != rhs.m_cuFunctionNVX;
}
bool operator<( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_cuFunctionNVX < rhs.m_cuFunctionNVX;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT
{
return m_cuFunctionNVX;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_cuFunctionNVX != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_cuFunctionNVX == VK_NULL_HANDLE;
}
private:
VkCuFunctionNVX m_cuFunctionNVX = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuFunctionNVX ) == sizeof( VkCuFunctionNVX ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::value,
"CuFunctionNVX is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCuFunctionNVX>
{
using type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX>
{
using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX>
{
using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class CuModuleNVX
{
public:
using CType = VkCuModuleNVX;
using NativeType = VkCuModuleNVX;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;
public:
VULKAN_HPP_CONSTEXPR CuModuleNVX() = default;
VULKAN_HPP_CONSTEXPR CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
: m_cuModuleNVX( cuModuleNVX )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
{
m_cuModuleNVX = cuModuleNVX;
return *this;
}
#endif
CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_cuModuleNVX = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CuModuleNVX const & ) const = default;
#else
bool operator==( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_cuModuleNVX == rhs.m_cuModuleNVX;
}
bool operator!=( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_cuModuleNVX != rhs.m_cuModuleNVX;
}
bool operator<( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_cuModuleNVX < rhs.m_cuModuleNVX;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT
{
return m_cuModuleNVX;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_cuModuleNVX != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_cuModuleNVX == VK_NULL_HANDLE;
}
private:
VkCuModuleNVX m_cuModuleNVX = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuModuleNVX ) == sizeof( VkCuModuleNVX ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CuModuleNVX>::value,
"CuModuleNVX is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCuModuleNVX>
{
using type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX>
{
using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX>
{
using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuModuleNVX>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class DescriptorPool
{
public:
using CType = VkDescriptorPool;
using NativeType = VkDescriptorPool;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;
public:
VULKAN_HPP_CONSTEXPR DescriptorPool() = default;
VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
: m_descriptorPool( descriptorPool )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
{
m_descriptorPool = descriptorPool;
return *this;
}
#endif
DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_descriptorPool = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorPool const & ) const = default;
#else
bool operator==( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_descriptorPool == rhs.m_descriptorPool;
}
bool operator!=( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_descriptorPool != rhs.m_descriptorPool;
}
bool operator<( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_descriptorPool < rhs.m_descriptorPool;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT
{
return m_descriptorPool;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_descriptorPool != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_descriptorPool == VK_NULL_HANDLE;
}
private:
VkDescriptorPool m_descriptorPool = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPool ) == sizeof( VkDescriptorPool ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorPool>::value,
"DescriptorPool is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorPool>
{
using type = VULKAN_HPP_NAMESPACE::DescriptorPool;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool>
{
using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool>
{
using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorPool>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class DescriptorSetLayout
{
public:
using CType = VkDescriptorSetLayout;
using NativeType = VkDescriptorSetLayout;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;
public:
VULKAN_HPP_CONSTEXPR DescriptorSetLayout() = default;
VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
: m_descriptorSetLayout( descriptorSetLayout )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
{
m_descriptorSetLayout = descriptorSetLayout;
return *this;
}
#endif
DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_descriptorSetLayout = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DescriptorSetLayout const & ) const = default;
#else
bool operator==( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
}
bool operator!=( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
}
bool operator<( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
{
return m_descriptorSetLayout;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_descriptorSetLayout != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_descriptorSetLayout == VK_NULL_HANDLE;
}
private:
VkDescriptorSetLayout m_descriptorSetLayout = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::value,
"DescriptorSetLayout is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorSetLayout>
{
using type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout>
{
using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout>
{
using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class Framebuffer
{
public:
using CType = VkFramebuffer;
using NativeType = VkFramebuffer;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;
public:
VULKAN_HPP_CONSTEXPR Framebuffer() = default;
VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
: m_framebuffer( framebuffer )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
Framebuffer & operator=( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
{
m_framebuffer = framebuffer;
return *this;
}
#endif
Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_framebuffer = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Framebuffer const & ) const = default;
#else
bool operator==( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_framebuffer == rhs.m_framebuffer;
}
bool operator!=( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_framebuffer != rhs.m_framebuffer;
}
bool operator<( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_framebuffer < rhs.m_framebuffer;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT
{
return m_framebuffer;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_framebuffer != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_framebuffer == VK_NULL_HANDLE;
}
private:
VkFramebuffer m_framebuffer = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Framebuffer ) == sizeof( VkFramebuffer ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Framebuffer>::value,
"Framebuffer is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eFramebuffer>
{
using type = VULKAN_HPP_NAMESPACE::Framebuffer;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer>
{
using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer>
{
using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Framebuffer>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class IndirectCommandsLayoutNV
{
public:
using CType = VkIndirectCommandsLayoutNV;
using NativeType = VkIndirectCommandsLayoutNV;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
public:
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV() = default;
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT
IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
: m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
{
m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;
return *this;
}
#endif
IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_indirectCommandsLayoutNV = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( IndirectCommandsLayoutNV const & ) const = default;
#else
bool operator==( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_indirectCommandsLayoutNV == rhs.m_indirectCommandsLayoutNV;
}
bool operator!=( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_indirectCommandsLayoutNV != rhs.m_indirectCommandsLayoutNV;
}
bool operator<( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_indirectCommandsLayoutNV < rhs.m_indirectCommandsLayoutNV;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT
{
return m_indirectCommandsLayoutNV;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;
}
private:
VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV ) ==
sizeof( VkIndirectCommandsLayoutNV ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::value,
"IndirectCommandsLayoutNV is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eIndirectCommandsLayoutNV>
{
using type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV>
{
using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class PrivateDataSlotEXT
{
public:
using CType = VkPrivateDataSlotEXT;
using NativeType = VkPrivateDataSlotEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlotEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
public:
VULKAN_HPP_CONSTEXPR PrivateDataSlotEXT() = default;
VULKAN_HPP_CONSTEXPR PrivateDataSlotEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlotEXT( VkPrivateDataSlotEXT privateDataSlotEXT ) VULKAN_HPP_NOEXCEPT
: m_privateDataSlotEXT( privateDataSlotEXT )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
PrivateDataSlotEXT & operator=( VkPrivateDataSlotEXT privateDataSlotEXT ) VULKAN_HPP_NOEXCEPT
{
m_privateDataSlotEXT = privateDataSlotEXT;
return *this;
}
#endif
PrivateDataSlotEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_privateDataSlotEXT = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PrivateDataSlotEXT const & ) const = default;
#else
bool operator==( PrivateDataSlotEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_privateDataSlotEXT == rhs.m_privateDataSlotEXT;
}
bool operator!=( PrivateDataSlotEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_privateDataSlotEXT != rhs.m_privateDataSlotEXT;
}
bool operator<( PrivateDataSlotEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_privateDataSlotEXT < rhs.m_privateDataSlotEXT;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlotEXT() const VULKAN_HPP_NOEXCEPT
{
return m_privateDataSlotEXT;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_privateDataSlotEXT != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_privateDataSlotEXT == VK_NULL_HANDLE;
}
private:
VkPrivateDataSlotEXT m_privateDataSlotEXT = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT ) == sizeof( VkPrivateDataSlotEXT ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>::value,
"PrivateDataSlotEXT is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePrivateDataSlotEXT>
{
using type = VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlotEXT>
{
using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class RenderPass
{
public:
using CType = VkRenderPass;
using NativeType = VkRenderPass;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;
public:
VULKAN_HPP_CONSTEXPR RenderPass() = default;
VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT
{
m_renderPass = renderPass;
return *this;
}
#endif
RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_renderPass = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderPass const & ) const = default;
#else
bool operator==( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_renderPass == rhs.m_renderPass;
}
bool operator!=( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_renderPass != rhs.m_renderPass;
}
bool operator<( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_renderPass < rhs.m_renderPass;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT
{
return m_renderPass;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_renderPass != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_renderPass == VK_NULL_HANDLE;
}
private:
VkRenderPass m_renderPass = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPass ) == sizeof( VkRenderPass ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPass>::value,
"RenderPass is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eRenderPass>
{
using type = VULKAN_HPP_NAMESPACE::RenderPass;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass>
{
using Type = VULKAN_HPP_NAMESPACE::RenderPass;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass>
{
using Type = VULKAN_HPP_NAMESPACE::RenderPass;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::RenderPass>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class Sampler
{
public:
using CType = VkSampler;
using NativeType = VkSampler;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eSampler;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;
public:
VULKAN_HPP_CONSTEXPR Sampler() = default;
VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
Sampler & operator=( VkSampler sampler ) VULKAN_HPP_NOEXCEPT
{
m_sampler = sampler;
return *this;
}
#endif
Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_sampler = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Sampler const & ) const = default;
#else
bool operator==( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_sampler == rhs.m_sampler;
}
bool operator!=( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_sampler != rhs.m_sampler;
}
bool operator<( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_sampler < rhs.m_sampler;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT
{
return m_sampler;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_sampler != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_sampler == VK_NULL_HANDLE;
}
private:
VkSampler m_sampler = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Sampler ) == sizeof( VkSampler ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Sampler>::value,
"Sampler is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSampler>
{
using type = VULKAN_HPP_NAMESPACE::Sampler;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSampler>
{
using Type = VULKAN_HPP_NAMESPACE::Sampler;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler>
{
using Type = VULKAN_HPP_NAMESPACE::Sampler;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Sampler>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class SamplerYcbcrConversion
{
public:
using CType = VkSamplerYcbcrConversion;
using NativeType = VkSamplerYcbcrConversion;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;
public:
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() = default;
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT
SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
: m_samplerYcbcrConversion( samplerYcbcrConversion )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
{
m_samplerYcbcrConversion = samplerYcbcrConversion;
return *this;
}
#endif
SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_samplerYcbcrConversion = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SamplerYcbcrConversion const & ) const = default;
#else
bool operator==( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
}
bool operator!=( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
}
bool operator<( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
{
return m_samplerYcbcrConversion;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_samplerYcbcrConversion != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_samplerYcbcrConversion == VK_NULL_HANDLE;
}
private:
VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ) ==
sizeof( VkSamplerYcbcrConversion ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::value,
"SamplerYcbcrConversion is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSamplerYcbcrConversion>
{
using type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion>
{
using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion>
{
using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
class ShaderModule
{
public:
using CType = VkShaderModule;
using NativeType = VkShaderModule;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;
public:
VULKAN_HPP_CONSTEXPR ShaderModule() = default;
VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
: m_shaderModule( shaderModule )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
{
m_shaderModule = shaderModule;
return *this;
}
#endif
ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_shaderModule = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ShaderModule const & ) const = default;
#else
bool operator==( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_shaderModule == rhs.m_shaderModule;
}
bool operator!=( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_shaderModule != rhs.m_shaderModule;
}
bool operator<( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_shaderModule < rhs.m_shaderModule;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT
{
return m_shaderModule;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_shaderModule != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_shaderModule == VK_NULL_HANDLE;
}
private:
VkShaderModule m_shaderModule = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderModule ) == sizeof( VkShaderModule ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShaderModule>::value,
"ShaderModule is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eShaderModule>
{
using type = VULKAN_HPP_NAMESPACE::ShaderModule;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule>
{
using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule>
{
using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderModule>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class ValidationCacheEXT
{
public:
using CType = VkValidationCacheEXT;
using NativeType = VkValidationCacheEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;
public:
VULKAN_HPP_CONSTEXPR ValidationCacheEXT() = default;
VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
: m_validationCacheEXT( validationCacheEXT )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
{
m_validationCacheEXT = validationCacheEXT;
return *this;
}
#endif
ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_validationCacheEXT = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( ValidationCacheEXT const & ) const = default;
#else
bool operator==( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_validationCacheEXT == rhs.m_validationCacheEXT;
}
bool operator!=( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_validationCacheEXT != rhs.m_validationCacheEXT;
}
bool operator<( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_validationCacheEXT < rhs.m_validationCacheEXT;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT
{
return m_validationCacheEXT;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_validationCacheEXT != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_validationCacheEXT == VK_NULL_HANDLE;
}
private:
VkValidationCacheEXT m_validationCacheEXT = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::value,
"ValidationCacheEXT is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eValidationCacheEXT>
{
using type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT>
{
using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT>
{
using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
#if defined( VK_ENABLE_BETA_EXTENSIONS )
class VideoSessionParametersKHR
{
public:
using CType = VkVideoSessionParametersKHR;
using NativeType = VkVideoSessionParametersKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
public:
VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR() = default;
VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT
VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
: m_videoSessionParametersKHR( videoSessionParametersKHR )
{}
# if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
{
m_videoSessionParametersKHR = videoSessionParametersKHR;
return *this;
}
# endif
VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_videoSessionParametersKHR = {};
return *this;
}
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoSessionParametersKHR const & ) const = default;
# else
bool operator==( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_videoSessionParametersKHR == rhs.m_videoSessionParametersKHR;
}
bool operator!=( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_videoSessionParametersKHR != rhs.m_videoSessionParametersKHR;
}
bool operator<( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_videoSessionParametersKHR < rhs.m_videoSessionParametersKHR;
}
# endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT
{
return m_videoSessionParametersKHR;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_videoSessionParametersKHR != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_videoSessionParametersKHR == VK_NULL_HANDLE;
}
private:
VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR ) ==
sizeof( VkVideoSessionParametersKHR ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::value,
"VideoSessionParametersKHR is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eVideoSessionParametersKHR>
{
using type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR>
{
using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
class Queue
{
public:
using CType = VkQueue;
using NativeType = VkQueue;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eQueue;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;
public:
VULKAN_HPP_CONSTEXPR Queue() = default;
VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
Queue & operator=( VkQueue queue ) VULKAN_HPP_NOEXCEPT
{
m_queue = queue;
return *this;
}
#endif
Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_queue = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Queue const & ) const = default;
#else
bool operator==( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_queue == rhs.m_queue;
}
bool operator!=( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_queue != rhs.m_queue;
}
bool operator<( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_queue < rhs.m_queue;
}
#endif
//=== VK_VERSION_1_0 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
submit( uint32_t submitCount,
const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits,
VULKAN_HPP_NAMESPACE::Fence fence,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
bindSparse( uint32_t bindInfoCount,
const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo,
VULKAN_HPP_NAMESPACE::Fence fence,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
bindSparse( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_swapchain ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result presentKHR( const PresentInfoKHR & presentInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_debug_utils ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_NV_device_diagnostic_checkpoints ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getCheckpointDataNV( uint32_t * pCheckpointDataCount,
VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = CheckpointDataNVAllocator,
typename std::enable_if<std::is_same<typename B::value_type, CheckpointDataNV>::value, int>::type = 0>
VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_INTEL_performance_query ===
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL(
VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_synchronization2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
submit2KHR( uint32_t submitCount,
const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR * pSubmits,
VULKAN_HPP_NAMESPACE::Fence fence,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
submit2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR> const & submits,
VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getCheckpointData2NV( uint32_t * pCheckpointDataCount,
VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = CheckpointData2NVAllocator,
typename std::enable_if<std::is_same<typename B::value_type, CheckpointData2NV>::value, int>::type = 0>
VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const VULKAN_HPP_NOEXCEPT
{
return m_queue;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_queue != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_queue == VK_NULL_HANDLE;
}
private:
VkQueue m_queue = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Queue ) == sizeof( VkQueue ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Queue>::value,
"Queue is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eQueue>
{
using type = VULKAN_HPP_NAMESPACE::Queue;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueue>
{
using Type = VULKAN_HPP_NAMESPACE::Queue;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue>
{
using Type = VULKAN_HPP_NAMESPACE::Queue;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Queue>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
#ifndef VULKAN_HPP_NO_SMART_HANDLE
class Device;
template <typename Dispatch>
class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Buffer, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<BufferView, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<CommandBuffer, Dispatch>
{
public:
using deleter = PoolFree<Device, CommandPool, Dispatch>;
};
using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<CommandPool, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<CuFunctionNVX, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<CuModuleNVX, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DescriptorPool, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DescriptorSet, Dispatch>
{
public:
using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
};
using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueDescriptorUpdateTemplate = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DeviceMemory, Dispatch>
{
public:
using deleter = ObjectFree<Device, Dispatch>;
};
using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Event, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Fence, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Framebuffer, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Image, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<ImageView, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Pipeline, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<PipelineCache, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<PipelineLayout, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<PrivateDataSlotEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlotEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<QueryPool, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<RenderPass, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Sampler, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueSamplerYcbcrConversion = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<Semaphore, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<ShaderModule, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<SwapchainKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <typename Dispatch>
class UniqueHandleTraits<VideoSessionKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <typename Dispatch>
class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
};
using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
class Device
{
public:
using CType = VkDevice;
using NativeType = VkDevice;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eDevice;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;
public:
VULKAN_HPP_CONSTEXPR Device() = default;
VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
Device & operator=( VkDevice device ) VULKAN_HPP_NOEXCEPT
{
m_device = device;
return *this;
}
#endif
Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_device = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Device const & ) const = default;
#else
bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_device == rhs.m_device;
}
bool operator!=( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_device != rhs.m_device;
}
bool operator<( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_device < rhs.m_device;
}
#endif
//=== VK_VERSION_1_0 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
PFN_vkVoidFunction
getProcAddr( const char * pName,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
PFN_vkVoidFunction
getProcAddr( const std::string & name,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getQueue( uint32_t queueFamilyIndex,
uint32_t queueIndex,
VULKAN_HPP_NAMESPACE::Queue * pQueue,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
getQueue( uint32_t queueFamilyIndex,
uint32_t queueIndex,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo * pAllocateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::DeviceMemory * pMemory,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceMemory>::type
allocateMemory( const MemoryAllocateInfo & allocateInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>>::type
allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void free( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void free( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
VULKAN_HPP_NAMESPACE::DeviceSize size,
VULKAN_HPP_NAMESPACE::MemoryMapFlags flags,
void ** ppData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void *>::type
mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
VULKAN_HPP_NAMESPACE::DeviceSize size,
VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
flushMappedMemoryRanges( uint32_t memoryRangeCount,
const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
flushMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges(
uint32_t memoryRangeCount,
const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
invalidateMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize
getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceMemory memory,
VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceMemory memory,
VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
bindImageMemory( VULKAN_HPP_NAMESPACE::Image image,
VULKAN_HPP_NAMESPACE::DeviceMemory memory,
VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
bindImageMemory( VULKAN_HPP_NAMESPACE::Image image,
VULKAN_HPP_NAMESPACE::DeviceMemory memory,
VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getBufferMemoryRequirements(
VULKAN_HPP_NAMESPACE::Buffer buffer,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getImageMemoryRequirements(
VULKAN_HPP_NAMESPACE::Image image,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getImageSparseMemoryRequirements(
VULKAN_HPP_NAMESPACE::Image image,
uint32_t * pSparseMemoryRequirementCount,
VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = SparseImageMemoryRequirementsAllocator,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::Fence * pFence,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
createFence( const FenceCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
createFenceUnique( const FenceCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Fence fence,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Fence fence,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
resetFences( uint32_t fenceCount,
const VULKAN_HPP_NAMESPACE::Fence * pFences,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type
resetFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
waitForFences( uint32_t fenceCount,
const VULKAN_HPP_NAMESPACE::Fence * pFences,
VULKAN_HPP_NAMESPACE::Bool32 waitAll,
uint64_t timeout,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result waitForFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
VULKAN_HPP_NAMESPACE::Bool32 waitAll,
uint64_t timeout,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::Semaphore * pSemaphore,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type
createSemaphore( const SemaphoreCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type
createSemaphoreUnique( const SemaphoreCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::Event * pEvent,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type
createEvent( const EventCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type
createEventUnique( const EventCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyEvent( VULKAN_HPP_NAMESPACE::Event event,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyEvent( VULKAN_HPP_NAMESPACE::Event event VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Event event,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Event event,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
setEvent( VULKAN_HPP_NAMESPACE::Event event,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
resetEvent( VULKAN_HPP_NAMESPACE::Event event,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type
resetEvent( VULKAN_HPP_NAMESPACE::Event event,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::QueryPool * pQueryPool,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type
createQueryPool( const QueryPoolCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type
createQueryPoolUnique( const QueryPoolCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
size_t dataSize,
void * pData,
VULKAN_HPP_NAMESPACE::DeviceSize stride,
VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
ArrayProxy<T> const & data,
VULKAN_HPP_NAMESPACE::DeviceSize stride,
VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T,
typename Allocator = std::allocator<T>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<std::vector<T, Allocator>>
getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
size_t dataSize,
VULKAN_HPP_NAMESPACE::DeviceSize stride,
VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<T>
getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
VULKAN_HPP_NAMESPACE::DeviceSize stride,
VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::Buffer * pBuffer,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Buffer>::type
createBuffer( const BufferCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>>::type
createBufferUnique( const BufferCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Buffer buffer,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Buffer buffer,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::BufferView * pView,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferView>::type
createBufferView( const BufferViewCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type
createBufferViewUnique( const BufferViewCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::Image * pImage,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type
createImage( const ImageCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type
createImageUnique( const ImageCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyImage( VULKAN_HPP_NAMESPACE::Image image,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyImage( VULKAN_HPP_NAMESPACE::Image image VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Image image,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Image image,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image image,
const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource,
VULKAN_HPP_NAMESPACE::SubresourceLayout * pLayout,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout getImageSubresourceLayout(
VULKAN_HPP_NAMESPACE::Image image,
const ImageSubresource & subresource,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::ImageView * pView,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type
createImageView( const ImageViewCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type
createImageViewUnique( const ImageViewCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::ImageView imageView,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::ImageView imageView,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::ShaderModule * pShaderModule,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type
createShaderModule( const ShaderModuleCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type
createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::PipelineCache * pPipelineCache,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type
createPipelineCache( const PipelineCacheCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type
createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
size_t * pDataSize,
void * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Uint8_tAllocator = std::allocator<uint8_t>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Uint8_tAllocator = std::allocator<uint8_t>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = Uint8_tAllocator,
typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
Uint8_tAllocator & uint8_tAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache dstCache,
uint32_t srcCacheCount,
const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache dstCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
uint32_t createInfoCount,
const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::Pipeline * pPipelines,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createGraphicsPipelines(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PipelineAllocator,
typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
Optional<const AllocationCallbacks> allocator,
PipelineAllocator & pipelineAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<Pipeline> createGraphicsPipeline(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
createGraphicsPipelinesUnique(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
typename B = PipelineAllocator,
typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
createGraphicsPipelinesUnique(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
Optional<const AllocationCallbacks> allocator,
PipelineAllocator & pipelineAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createGraphicsPipelineUnique(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
uint32_t createInfoCount,
const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfos,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::Pipeline * pPipelines,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createComputePipelines(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PipelineAllocator,
typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
Optional<const AllocationCallbacks> allocator,
PipelineAllocator & pipelineAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<Pipeline> createComputePipeline(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
createComputePipelinesUnique(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
typename B = PipelineAllocator,
typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
createComputePipelinesUnique(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
Optional<const AllocationCallbacks> allocator,
PipelineAllocator & pipelineAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createComputePipelineUnique(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::PipelineLayout * pPipelineLayout,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type
createPipelineLayout( const PipelineLayoutCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type
createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyPipelineLayout(
VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::Sampler * pSampler,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type
createSampler( const SamplerCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type
createSamplerUnique( const SamplerCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Sampler sampler,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Sampler sampler,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createDescriptorSetLayout(
const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::DescriptorSetLayout * pSetLayout,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type
createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type
createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyDescriptorSetLayout(
VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::DescriptorPool * pDescriptorPool,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorPool>::type
createDescriptorPool( const DescriptorPoolCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type
createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyDescriptorPool(
VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type
resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo,
VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = DescriptorSetAllocator,
typename std::enable_if<std::is_same<typename B::value_type, DescriptorSet>::value, int>::type = 0>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
DescriptorSetAllocator & descriptorSetAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename DescriptorSetAllocator = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename DescriptorSetAllocator = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>,
typename B = DescriptorSetAllocator,
typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
DescriptorSetAllocator & descriptorSetAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
uint32_t descriptorSetCount,
const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type
freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result free( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
uint32_t descriptorSetCount,
const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type
free( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void updateDescriptorSets( uint32_t descriptorWriteCount,
const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
uint32_t descriptorCopyCount,
const VULKAN_HPP_NAMESPACE::CopyDescriptorSet * pDescriptorCopies,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void updateDescriptorSets( ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::Framebuffer * pFramebuffer,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type
createFramebuffer( const FramebufferCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type
createFramebufferUnique( const FramebufferCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
createRenderPass( const RenderPassCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
createRenderPassUnique( const RenderPassCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::CommandPool * pCommandPool,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type
createCommandPool( const CommandPoolCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type
createCommandPoolUnique( const CommandPoolCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type
resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo,
VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = CommandBufferAllocator,
typename std::enable_if<std::is_same<typename B::value_type, CommandBuffer>::value, int>::type = 0>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
CommandBufferAllocator & commandBufferAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename CommandBufferAllocator = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename CommandBufferAllocator = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>,
typename B = CommandBufferAllocator,
typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
CommandBufferAllocator & commandBufferAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
uint32_t commandBufferCount,
const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void free( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
uint32_t commandBufferCount,
const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void free( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_VERSION_1_1 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
bindBufferMemory2( uint32_t bindInfoCount,
const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
bindBufferMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
bindImageMemory2( uint32_t bindInfoCount,
const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
bindImageMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getGroupPeerMemoryFeatures( uint32_t heapIndex,
uint32_t localDeviceIndex,
uint32_t remoteDeviceIndex,
VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures(
uint32_t heapIndex,
uint32_t localDeviceIndex,
uint32_t remoteDeviceIndex,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2(
const ImageMemoryRequirementsInfo2 & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2(
const ImageMemoryRequirementsInfo2 & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2(
const BufferMemoryRequirementsInfo2 & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2(
const BufferMemoryRequirementsInfo2 & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getImageSparseMemoryRequirements2(
const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
uint32_t * pSparseMemoryRequirementCount,
VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = SparseImageMemoryRequirements2Allocator,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
getImageSparseMemoryRequirements2(
const ImageSparseMemoryRequirementsInfo2 & info,
SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo,
VULKAN_HPP_NAMESPACE::Queue * pQueue,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
getQueue2( const DeviceQueueInfo2 & queueInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion(
const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroySamplerYcbcrConversion(
VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate(
const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type
createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyDescriptorUpdateTemplate(
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
const void * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport * pSupport,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport(
const DescriptorSetLayoutCreateInfo & createInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport(
const DescriptorSetLayoutCreateInfo & createInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_VERSION_1_2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
createRenderPass2( const RenderPassCreateInfo2 & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
createRenderPass2Unique( const RenderPassCreateInfo2 & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
uint64_t * pValue,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
uint64_t timeout,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result waitSemaphores( const SemaphoreWaitInfo & waitInfo,
uint64_t timeout,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
signalSemaphore( const SemaphoreSignalInfo & signalInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
DeviceAddress
getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
DeviceAddress
getBufferAddress( const BufferDeviceAddressInfo & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
uint64_t getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
uint64_t getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_swapchain ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchain,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
uint32_t * pSwapchainImageCount,
VULKAN_HPP_NAMESPACE::Image * pSwapchainImages,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename ImageAllocator = std::allocator<Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename ImageAllocator = std::allocator<Image>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = ImageAllocator,
typename std::enable_if<std::is_same<typename B::value_type, Image>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
ImageAllocator & imageAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
uint64_t timeout,
VULKAN_HPP_NAMESPACE::Semaphore semaphore,
VULKAN_HPP_NAMESPACE::Fence fence,
uint32_t * pImageIndex,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<uint32_t>
acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
uint64_t timeout,
VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR(
VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type
getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR(
VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo,
uint32_t * pImageIndex,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<uint32_t>
acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_display_swapchain ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR(
uint32_t swapchainCount,
const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = SwapchainKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, SwapchainKHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
Optional<const AllocationCallbacks> allocator,
SwapchainKHRAllocator & swapchainKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR(
const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename SwapchainKHRAllocator = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
createSharedSwapchainsKHRUnique(
ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename SwapchainKHRAllocator = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>,
typename B = SwapchainKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
createSharedSwapchainsKHRUnique(
ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
Optional<const AllocationCallbacks> allocator,
SwapchainKHRAllocator & swapchainKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_debug_marker ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT(
const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT(
const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_video_queue ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::VideoSessionKHR * pVideoSession,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type
createVideoSessionKHR( const VideoSessionCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type
createVideoSessionKHRUnique( const VideoSessionCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyVideoSessionKHR(
VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR(
VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
uint32_t * pVideoSessionMemoryRequirementsCount,
VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR * pVideoSessionMemoryRequirements,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename VideoGetMemoryPropertiesKHRAllocator = std::allocator<VideoGetMemoryPropertiesKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename VideoGetMemoryPropertiesKHRAllocator = std::allocator<VideoGetMemoryPropertiesKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = VideoGetMemoryPropertiesKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, VideoGetMemoryPropertiesKHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
VideoGetMemoryPropertiesKHRAllocator & videoGetMemoryPropertiesKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR(
VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
uint32_t videoSessionBindMemoryCount,
const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR * pVideoSessionBindMemories,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindVideoSessionMemoryKHR(
VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR(
const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR * pVideoSessionParameters,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type
createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type
createVideoSessionParametersKHRUnique( const VideoSessionParametersCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR(
VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
const VideoSessionParametersUpdateInfoKHR & updateInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyVideoSessionParametersKHR(
VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_NVX_binary_import ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::CuModuleNVX * pModule,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type
createCuModuleNVX( const CuModuleCreateInfoNVX & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type
createCuModuleNVXUnique( const CuModuleCreateInfoNVX & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::CuFunctionNVX * pFunction,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type
createCuFunctionNVX( const CuFunctionCreateInfoNVX & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type
createCuFunctionNVXUnique( const CuFunctionCreateInfoNVX & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_NVX_image_view_handle ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
uint32_t
getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
uint32_t
getImageViewHandleNVX( const ImageViewHandleInfoNVX & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView,
VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type
getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_AMD_shader_info ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType,
size_t * pInfoSize,
void * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Uint8_tAllocator = std::allocator<uint8_t>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Uint8_tAllocator = std::allocator<uint8_t>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = Uint8_tAllocator,
typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType,
Uint8_tAllocator & uint8_tAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_external_memory_win32 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
HANDLE * pHandle,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_device_group ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex,
uint32_t localDeviceIndex,
uint32_t remoteDeviceIndex,
VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR(
uint32_t heapIndex,
uint32_t localDeviceIndex,
uint32_t remoteDeviceIndex,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_maintenance1 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_memory_win32 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
HANDLE * pHandle,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR(
VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
HANDLE handle,
VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type
getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
HANDLE handle,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_memory_fd ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo,
int * pFd,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
int fd,
VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR * pMemoryFdProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type
getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
int fd,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_semaphore_win32 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR(
const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR(
const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
HANDLE * pHandle,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_semaphore_fd ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo,
int * pFd,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_descriptor_update_template ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR(
const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type
createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyDescriptorUpdateTemplateKHR(
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
const void * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_display_control ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type
displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
const DisplayPowerInfoEXT & displayPowerInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT * pDeviceEventInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::Fence * pFence,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::Fence * pFence,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type registerDisplayEventEXT(
VULKAN_HPP_NAMESPACE::DisplayKHR display,
const DisplayEventInfoEXT & displayEventInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display,
const DisplayEventInfoEXT & displayEventInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
uint64_t * pCounterValue,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_GOOGLE_display_timing ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE(
VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type
getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE(
VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
uint32_t * pPresentationTimingCount,
VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PastPresentationTimingGOOGLEAllocator,
typename std::enable_if<std::is_same<typename B::value_type, PastPresentationTimingGOOGLE>::value, int>::type = 0>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_hdr_metadata ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setHdrMetadataEXT( uint32_t swapchainCount,
const VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains,
const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains,
ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_create_renderpass2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
createRenderPass2KHR( const RenderPassCreateInfo2 & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
createRenderPass2KHRUnique( const RenderPassCreateInfo2 & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_shared_presentable_image ===
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR(
VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_external_fence_win32 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR(
const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
HANDLE * pHandle,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_external_fence_fd ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo,
int * pFd,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_performance_query ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_debug_utils ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT(
const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT(
const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_ANDROID_external_memory_android_hardware_buffer ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getAndroidHardwareBufferPropertiesANDROID(
const struct AHardwareBuffer * buffer,
VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type
getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID(
const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
struct AHardwareBuffer ** pBuffer,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<struct AHardwareBuffer *>::type
getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
//=== VK_KHR_get_memory_requirements2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2KHR(
const ImageMemoryRequirementsInfo2 & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR(
const ImageMemoryRequirementsInfo2 & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2KHR(
const BufferMemoryRequirementsInfo2 & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR(
const BufferMemoryRequirementsInfo2 & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getImageSparseMemoryRequirements2KHR(
const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
uint32_t * pSparseMemoryRequirementCount,
VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = SparseImageMemoryRequirements2Allocator,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
getImageSparseMemoryRequirements2KHR(
const ImageSparseMemoryRequirementsInfo2 & info,
SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_acceleration_structure ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR(
const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructure,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type
createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type
createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyAccelerationStructureKHR(
VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
uint32_t infoCount,
const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result buildAccelerationStructuresKHR(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
const CopyAccelerationStructureInfoKHR & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
const CopyAccelerationStructureToMemoryInfoKHR & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
const CopyMemoryToAccelerationStructureInfoKHR & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result writeAccelerationStructuresPropertiesKHR(
uint32_t accelerationStructureCount,
const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
VULKAN_HPP_NAMESPACE::QueryType queryType,
size_t dataSize,
void * pData,
size_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
writeAccelerationStructuresPropertiesKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
VULKAN_HPP_NAMESPACE::QueryType queryType,
ArrayProxy<T> const & data,
size_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T,
typename Allocator = std::allocator<T>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
writeAccelerationStructuresPropertiesKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
VULKAN_HPP_NAMESPACE::QueryType queryType,
size_t dataSize,
size_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type writeAccelerationStructuresPropertyKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
VULKAN_HPP_NAMESPACE::QueryType queryType,
size_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
DeviceAddress getAccelerationStructureAddressKHR(
const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
DeviceAddress getAccelerationStructureAddressKHR(
const AccelerationStructureDeviceAddressInfoKHR & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getAccelerationStructureCompatibilityKHR(
const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo,
VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR * pCompatibility,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getAccelerationStructureBuildSizesKHR(
VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
const uint32_t * pMaxPrimitiveCounts,
VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR * pSizeInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR
getAccelerationStructureBuildSizesKHR(
VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
const AccelerationStructureBuildGeometryInfoKHR & buildInfo,
ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_sampler_ycbcr_conversion ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR(
const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroySamplerYcbcrConversionKHR(
VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_bind_memory2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
bindBufferMemory2KHR( uint32_t bindInfoCount,
const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
bindBufferMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
bindImageMemory2KHR( uint32_t bindInfoCount,
const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_image_drm_format_modifier ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT(
VULKAN_HPP_NAMESPACE::Image image,
VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type
getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_validation_cache ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pValidationCache,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type createValidationCacheEXT(
const ValidationCacheCreateInfoEXT & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type
createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyValidationCacheEXT(
VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache,
uint32_t srcCacheCount,
const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT(
VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
size_t * pDataSize,
void * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Uint8_tAllocator = std::allocator<uint8_t>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Uint8_tAllocator = std::allocator<uint8_t>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = Uint8_tAllocator,
typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
Uint8_tAllocator & uint8_tAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_NV_ray_tracing ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createAccelerationStructureNV(
const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructure,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type createAccelerationStructureNV(
const AccelerationStructureCreateInfoNV & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type
createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyAccelerationStructureNV(
VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getAccelerationStructureMemoryRequirementsNV(
const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo,
VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR * pMemoryRequirements,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(
const AccelerationStructureMemoryRequirementsInfoNV & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV(
const AccelerationStructureMemoryRequirementsInfoNV & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV(
uint32_t bindInfoCount,
const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindAccelerationStructureMemoryNV(
ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
uint32_t createInfoCount,
const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::Pipeline * pPipelines,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesNV(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PipelineAllocator,
typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesNV(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
Optional<const AllocationCallbacks> allocator,
PipelineAllocator & pipelineAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<Pipeline> createRayTracingPipelineNV(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
createRayTracingPipelinesNVUnique(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
typename B = PipelineAllocator,
typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
createRayTracingPipelinesNVUnique(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
Optional<const AllocationCallbacks> allocator,
PipelineAllocator & pipelineAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createRayTracingPipelineNVUnique(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV(
VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup,
uint32_t groupCount,
size_t dataSize,
void * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup,
uint32_t groupCount,
ArrayProxy<T> const & data,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T,
typename Allocator = std::allocator<T>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup,
uint32_t groupCount,
size_t dataSize,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup,
uint32_t groupCount,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV(
VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
size_t dataSize,
void * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
ArrayProxy<T> const & data,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T,
typename Allocator = std::allocator<T>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
size_t dataSize,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t shader,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t shader,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_maintenance3 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport * pSupport,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR(
const DescriptorSetLayoutCreateInfo & createInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR(
const DescriptorSetLayoutCreateInfo & createInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_external_memory_host ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT(
VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
const void * pHostPointer,
VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type
getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
const void * pHostPointer,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_calibrated_timestamps ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT(
uint32_t timestampCount,
const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT * pTimestampInfos,
uint64_t * pTimestamps,
uint64_t * pMaxDeviation,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type getCalibratedTimestampsEXT(
ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
ArrayProxy<uint64_t> const & timestamps,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Uint64_tAllocator = std::allocator<uint64_t>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
getCalibratedTimestampsEXT(
ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Uint64_tAllocator = std::allocator<uint64_t>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = Uint64_tAllocator,
typename std::enable_if<std::is_same<typename B::value_type, uint64_t>::value, int>::type = 0>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
getCalibratedTimestampsEXT(
ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
Uint64_tAllocator & uint64_tAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_timeline_semaphore ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR(
VULKAN_HPP_NAMESPACE::Semaphore semaphore,
uint64_t * pValue,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
uint64_t timeout,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo,
uint64_t timeout,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_INTEL_performance_query ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL(
const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL(
const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL * pConfiguration,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type
acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type
acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL(
VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type releasePerformanceConfigurationINTEL(
VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL(
VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
VULKAN_HPP_NAMESPACE::PerformanceValueINTEL * pValue,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type
getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_AMD_display_native_hdr ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain,
VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_buffer_device_address ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
DeviceAddress
getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
DeviceAddress
getBufferAddressEXT( const BufferDeviceAddressInfo & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_present_wait ===
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
uint64_t presentId,
uint64_t timeout,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
uint64_t presentId,
uint64_t timeout,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_EXT_full_screen_exclusive ===
# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT(
VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT(
VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_KHR_buffer_device_address ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
DeviceAddress
getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
DeviceAddress
getBufferAddressKHR( const BufferDeviceAddressInfo & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
uint64_t getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
uint64_t getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_host_query_reset ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_KHR_deferred_host_operations ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createDeferredOperationKHR(
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::DeferredOperationKHR * pDeferredOperation,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type createDeferredOperationKHR(
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type
createDeferredOperationKHRUnique( Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyDeferredOperationKHR(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
uint32_t getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_pipeline_executable_properties ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR(
const VULKAN_HPP_NAMESPACE::PipelineInfoKHR * pPipelineInfo,
uint32_t * pExecutableCount,
VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<
std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PipelineExecutablePropertiesKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutablePropertiesKHR>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<
std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
getPipelineExecutablePropertiesKHR(
const PipelineInfoKHR & pipelineInfo,
PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR(
const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,
uint32_t * pStatisticCount,
VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR * pStatistics,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<
std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PipelineExecutableStatisticKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableStatisticKHR>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<
std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
getPipelineExecutableStatisticsKHR(
const PipelineExecutableInfoKHR & executableInfo,
PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getPipelineExecutableInternalRepresentationsKHR(
const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,
uint32_t * pInternalRepresentationCount,
VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineExecutableInternalRepresentationKHRAllocator =
std::allocator<PipelineExecutableInternalRepresentationKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
PipelineExecutableInternalRepresentationKHRAllocator>>::type
getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo,
Dispatch const & d
VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename PipelineExecutableInternalRepresentationKHRAllocator =
std::allocator<PipelineExecutableInternalRepresentationKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PipelineExecutableInternalRepresentationKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableInternalRepresentationKHR>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
PipelineExecutableInternalRepresentationKHRAllocator>>::type
getPipelineExecutableInternalRepresentationsKHR(
const PipelineExecutableInfoKHR & executableInfo,
PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_NV_device_generated_commands ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getGeneratedCommandsMemoryRequirementsNV(
const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo,
VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV(
const GeneratedCommandsMemoryRequirementsInfoNV & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getGeneratedCommandsMemoryRequirementsNV(
const GeneratedCommandsMemoryRequirementsInfoNV & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV(
const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV * pIndirectCommandsLayout,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::type
createIndirectCommandsLayoutNV( const IndirectCommandsLayoutCreateInfoNV & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type
createIndirectCommandsLayoutNVUnique( const IndirectCommandsLayoutCreateInfoNV & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyIndirectCommandsLayoutNV(
VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_private_data ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT * pPrivateDataSlot,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>::type createPrivateDataSlotEXT(
const PrivateDataSlotCreateInfoEXT & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT, Dispatch>>::type
createPrivateDataSlotEXTUnique( const PrivateDataSlotCreateInfoEXT & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyPrivateDataSlotEXT(
VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType,
uint64_t objectHandle,
VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
uint64_t data,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type
setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType,
uint64_t objectHandle,
VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
uint64_t data,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType,
uint64_t objectHandle,
VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
uint64_t * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD uint64_t
getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType,
uint64_t objectHandle,
VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_ray_tracing_pipeline ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
uint32_t createInfoCount,
const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR * pCreateInfos,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::Pipeline * pPipelines,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesKHR(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PipelineAllocator,
typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesKHR(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
Optional<const AllocationCallbacks> allocator,
PipelineAllocator & pipelineAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<Pipeline> createRayTracingPipelineKHR(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
createRayTracingPipelinesKHRUnique(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
typename B = PipelineAllocator,
typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
createRayTracingPipelinesKHRUnique(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
Optional<const AllocationCallbacks> allocator,
PipelineAllocator & pipelineAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createRayTracingPipelineKHRUnique(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR(
VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup,
uint32_t groupCount,
size_t dataSize,
void * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup,
uint32_t groupCount,
ArrayProxy<T> const & data,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T,
typename Allocator = std::allocator<T>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup,
uint32_t groupCount,
size_t dataSize,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup,
uint32_t groupCount,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR(
VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup,
uint32_t groupCount,
size_t dataSize,
void * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup,
uint32_t groupCount,
ArrayProxy<T> const & data,
Dispatch const & d
VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T,
typename Allocator = std::allocator<T>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup,
uint32_t groupCount,
size_t dataSize,
Dispatch const & d
VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
getRayTracingCaptureReplayShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup,
uint32_t groupCount,
Dispatch const & d
VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
DeviceSize getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t group,
VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_external_memory ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA(
const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
zx_handle_t * pZirconHandle,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<zx_handle_t>::type
getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getMemoryZirconHandlePropertiesFUCHSIA(
VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
zx_handle_t zirconHandle,
VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type
getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
zx_handle_t zirconHandle,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_external_semaphore ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result importSemaphoreZirconHandleFUCHSIA(
const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreZirconHandleFUCHSIA(
const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA(
const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
zx_handle_t * pZirconHandle,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<zx_handle_t>::type
getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_FUCHSIA*/
//=== VK_HUAWEI_subpass_shading ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getSubpassShadingMaxWorkgroupSizeHUAWEI(
VULKAN_HPP_NAMESPACE::RenderPass renderpass,
VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Extent2D>
getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_NV_external_memory_rdma ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
VULKAN_HPP_NAMESPACE::RemoteAddressNV * pAddress,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<VULKAN_HPP_NAMESPACE::RemoteAddressNV>::type
getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_pageable_device_local_memory ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setMemoryPriorityEXT( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
float priority,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const VULKAN_HPP_NOEXCEPT
{
return m_device;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_device != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_device == VK_NULL_HANDLE;
}
private:
VkDevice m_device = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Device ) == sizeof( VkDevice ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Device>::value,
"Device is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDevice>
{
using type = VULKAN_HPP_NAMESPACE::Device;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDevice>
{
using Type = VULKAN_HPP_NAMESPACE::Device;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice>
{
using Type = VULKAN_HPP_NAMESPACE::Device;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Device>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
class DisplayModeKHR
{
public:
using CType = VkDisplayModeKHR;
using NativeType = VkDisplayModeKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;
public:
VULKAN_HPP_CONSTEXPR DisplayModeKHR() = default;
VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
: m_displayModeKHR( displayModeKHR )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
{
m_displayModeKHR = displayModeKHR;
return *this;
}
#endif
DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_displayModeKHR = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayModeKHR const & ) const = default;
#else
bool operator==( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_displayModeKHR == rhs.m_displayModeKHR;
}
bool operator!=( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_displayModeKHR != rhs.m_displayModeKHR;
}
bool operator<( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_displayModeKHR < rhs.m_displayModeKHR;
}
#endif
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT
{
return m_displayModeKHR;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_displayModeKHR != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_displayModeKHR == VK_NULL_HANDLE;
}
private:
VkDisplayModeKHR m_displayModeKHR = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeKHR ) == sizeof( VkDisplayModeKHR ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::value,
"DisplayModeKHR is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDisplayModeKHR>
{
using type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR>
{
using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR>
{
using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch>
class UniqueHandleTraits<Device, Dispatch>
{
public:
using deleter = ObjectDestroy<NoParent, Dispatch>;
};
using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
class PhysicalDevice
{
public:
using CType = VkPhysicalDevice;
using NativeType = VkPhysicalDevice;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;
public:
VULKAN_HPP_CONSTEXPR PhysicalDevice() = default;
VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
: m_physicalDevice( physicalDevice )
{}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
PhysicalDevice & operator=( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
{
m_physicalDevice = physicalDevice;
return *this;
}
#endif
PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_physicalDevice = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevice const & ) const = default;
#else
bool operator==( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_physicalDevice == rhs.m_physicalDevice;
}
bool operator!=( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_physicalDevice != rhs.m_physicalDevice;
}
bool operator<( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_physicalDevice < rhs.m_physicalDevice;
}
#endif
//=== VK_VERSION_1_0 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties
getFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
VULKAN_HPP_NAMESPACE::ImageType type,
VULKAN_HPP_NAMESPACE::ImageTiling tiling,
VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,
VULKAN_HPP_NAMESPACE::ImageCreateFlags flags,
VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type
getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
VULKAN_HPP_NAMESPACE::ImageType type,
VULKAN_HPP_NAMESPACE::ImageTiling tiling,
VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,
VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount,
VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = QueueFamilyPropertiesAllocator,
typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties>::value, int>::type = 0>
VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::Device * pDevice,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type
createDevice( const DeviceCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type
createDeviceUnique( const DeviceCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties(
const char * pLayerName,
uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
enumerateDeviceExtensionProperties( Optional<const std::string> layerName
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = ExtensionPropertiesAllocator,
typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
enumerateDeviceExtensionProperties( Optional<const std::string> layerName,
ExtensionPropertiesAllocator & extensionPropertiesAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties(
uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = LayerPropertiesAllocator,
typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
VULKAN_HPP_NAMESPACE::ImageType type,
VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,
VULKAN_HPP_NAMESPACE::ImageTiling tiling,
uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
VULKAN_HPP_NAMESPACE::ImageType type,
VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,
VULKAN_HPP_NAMESPACE::ImageTiling tiling,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = SparseImageFormatPropertiesAllocator,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties>::value, int>::type = 0>
VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
VULKAN_HPP_NAMESPACE::ImageType type,
VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,
VULKAN_HPP_NAMESPACE::ImageTiling tiling,
SparseImageFormatPropertiesAllocator & sparseImageFormatPropertiesAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_VERSION_1_1 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getImageFormatProperties2(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount,
VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = QueueFamilyProperties2Allocator,
typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename StructureChain,
typename StructureChainAllocator = std::allocator<StructureChain>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename StructureChain,
typename StructureChainAllocator = std::allocator<StructureChain>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = StructureChainAllocator,
typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getSparseImageFormatProperties2(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = SparseImageFormatProperties2Allocator,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getExternalBufferProperties(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferProperties(
const PhysicalDeviceExternalBufferInfo & externalBufferInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFenceProperties(
const PhysicalDeviceExternalFenceInfo & externalFenceInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getExternalSemaphoreProperties(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphoreProperties(
const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getSurfaceSupportKHR( uint32_t queueFamilyIndex,
VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
VULKAN_HPP_NAMESPACE::Bool32 * pSupported,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type
getSurfaceSupportKHR( uint32_t queueFamilyIndex,
VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR(
VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type
getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
uint32_t * pSurfaceFormatCount,
VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = SurfaceFormatKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormatKHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
SurfaceFormatKHRAllocator & surfaceFormatKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR(
VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
uint32_t * pPresentModeCount,
VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PresentModeKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
PresentModeKHRAllocator & presentModeKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_swapchain ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
uint32_t * pRectCount,
VULKAN_HPP_NAMESPACE::Rect2D * pRects,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Rect2DAllocator = std::allocator<Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Rect2DAllocator = std::allocator<Rect2D>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = Rect2DAllocator,
typename std::enable_if<std::is_same<typename B::value_type, Rect2D>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
Rect2DAllocator & rect2DAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_display ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getDisplayPropertiesKHR( uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = DisplayPropertiesKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, DisplayPropertiesKHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR(
uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = DisplayPlanePropertiesKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, DisplayPlanePropertiesKHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR(
uint32_t planeIndex,
uint32_t * pDisplayCount,
VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = DisplayKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, DisplayKHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex,
DisplayKHRAllocator & displayKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR(
VULKAN_HPP_NAMESPACE::DisplayKHR display,
uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = DisplayModePropertiesKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, DisplayModePropertiesKHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::DisplayModeKHR * pMode,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type
createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
const DisplayModeCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type
createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display,
const DisplayModeCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR(
VULKAN_HPP_NAMESPACE::DisplayModeKHR mode,
uint32_t planeIndex,
VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type
getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode,
uint32_t planeIndex,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_USE_PLATFORM_XLIB_KHR )
//=== VK_KHR_xlib_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex,
Display * dpy,
VisualID visualID,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex,
Display & dpy,
VisualID visualID,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
#if defined( VK_USE_PLATFORM_XCB_KHR )
//=== VK_KHR_xcb_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex,
xcb_connection_t * connection,
xcb_visualid_t visual_id,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex,
xcb_connection_t & connection,
xcb_visualid_t visual_id,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_XCB_KHR*/
#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
//=== VK_KHR_wayland_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
struct wl_display * display,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
struct wl_display & display,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_win32_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_video_queue ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR * pVideoProfile,
VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR * pCapabilities,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type
getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
uint32_t * pVideoFormatPropertyCount,
VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR * pVideoFormatProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = VideoFormatPropertiesKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, VideoFormatPropertiesKHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_NV_external_memory_capabilities ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV(
VULKAN_HPP_NAMESPACE::Format format,
VULKAN_HPP_NAMESPACE::ImageType type,
VULKAN_HPP_NAMESPACE::ImageTiling tiling,
VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,
VULKAN_HPP_NAMESPACE::ImageCreateFlags flags,
VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType,
VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type
getExternalImageFormatPropertiesNV(
VULKAN_HPP_NAMESPACE::Format format,
VULKAN_HPP_NAMESPACE::ImageType type,
VULKAN_HPP_NAMESPACE::ImageTiling tiling,
VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,
VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_get_physical_device_properties2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount,
VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = QueueFamilyProperties2Allocator,
typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename StructureChain,
typename StructureChainAllocator = std::allocator<StructureChain>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename StructureChain,
typename StructureChainAllocator = std::allocator<StructureChain>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = StructureChainAllocator,
typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getSparseImageFormatProperties2KHR(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = SparseImageFormatProperties2Allocator,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_external_memory_capabilities ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getExternalBufferPropertiesKHR(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferPropertiesKHR(
const PhysicalDeviceExternalBufferInfo & externalBufferInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_external_semaphore_capabilities ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getExternalSemaphorePropertiesKHR(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR(
const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_direct_mode_display ===
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type
releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
//=== VK_EXT_acquire_xlib_display ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
acquireXlibDisplayEXT( Display * dpy,
VULKAN_HPP_NAMESPACE::DisplayKHR display,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
acquireXlibDisplayEXT( Display & dpy,
VULKAN_HPP_NAMESPACE::DisplayKHR display,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getRandROutputDisplayEXT( Display * dpy,
RROutput rrOutput,
VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getRandROutputDisplayEXT(
Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
getRandROutputDisplayEXTUnique( Display & dpy,
RROutput rrOutput,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
//=== VK_EXT_display_surface_counter ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT(
VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type
getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_external_fence_capabilities ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getExternalFencePropertiesKHR(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFencePropertiesKHR(
const PhysicalDeviceExternalFenceInfo & externalFenceInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_performance_query ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result enumerateQueueFamilyPerformanceQueryCountersKHR(
uint32_t queueFamilyIndex,
uint32_t * pCounterCount,
VULKAN_HPP_NAMESPACE::PerformanceCounterKHR * pCounters,
VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator = std::allocator<PerformanceCounterDescriptionKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR, Allocator>>::type
enumerateQueueFamilyPerformanceQueryCountersKHR(
uint32_t queueFamilyIndex,
ArrayProxy<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> const & counters,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Allocator = std::allocator<PerformanceCounterDescriptionKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = Allocator,
typename std::enable_if<std::is_same<typename B::value_type, PerformanceCounterDescriptionKHR>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR, Allocator>>::type
enumerateQueueFamilyPerformanceQueryCountersKHR(
uint32_t queueFamilyIndex,
ArrayProxy<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> const & counters,
Allocator const & vectorAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PerformanceCounterKHRAllocator = std::allocator<PerformanceCounterKHR>,
typename PerformanceCounterDescriptionKHRAllocator = std::allocator<PerformanceCounterDescriptionKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<
std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
enumerateQueueFamilyPerformanceQueryCountersKHR(
uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PerformanceCounterKHRAllocator = std::allocator<PerformanceCounterKHR>,
typename PerformanceCounterDescriptionKHRAllocator = std::allocator<PerformanceCounterDescriptionKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B1 = PerformanceCounterKHRAllocator,
typename B2 = PerformanceCounterDescriptionKHRAllocator,
typename std::enable_if<std::is_same<typename B1::value_type, PerformanceCounterKHR>::value &&
std::is_same<typename B2::value_type, PerformanceCounterDescriptionKHR>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<
std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
enumerateQueueFamilyPerformanceQueryCountersKHR(
uint32_t queueFamilyIndex,
PerformanceCounterKHRAllocator & performanceCounterKHRAllocator,
PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getQueueFamilyPerformanceQueryPassesKHR(
const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
uint32_t * pNumPasses,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR(
const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_get_surface_capabilities2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR * pSurfaceCapabilities,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type
getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
uint32_t * pSurfaceFormatCount,
VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR * pSurfaceFormats,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = SurfaceFormat2KHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormat2KHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
SurfaceFormat2KHRAllocator & surfaceFormat2KHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_get_display_properties2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getDisplayProperties2KHR( uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = DisplayProperties2KHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, DisplayProperties2KHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR(
uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = DisplayPlaneProperties2KHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, DisplayPlaneProperties2KHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR(
VULKAN_HPP_NAMESPACE::DisplayKHR display,
uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename DisplayModeProperties2KHRAllocator = std::allocator<DisplayModeProperties2KHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename DisplayModeProperties2KHRAllocator = std::allocator<DisplayModeProperties2KHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = DisplayModeProperties2KHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, DisplayModeProperties2KHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR(
const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR * pDisplayPlaneInfo,
VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type
getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_sample_locations ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT getMultisamplePropertiesEXT(
VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_calibrated_timestamps ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT(
uint32_t * pTimeDomainCount,
VULKAN_HPP_NAMESPACE::TimeDomainEXT * pTimeDomains,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename TimeDomainEXTAllocator = std::allocator<TimeDomainEXT>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainEXT, TimeDomainEXTAllocator>>::type
getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename TimeDomainEXTAllocator = std::allocator<TimeDomainEXT>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = TimeDomainEXTAllocator,
typename std::enable_if<std::is_same<typename B::value_type, TimeDomainEXT>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainEXT, TimeDomainEXTAllocator>>::type
getCalibrateableTimeDomainsEXT( TimeDomainEXTAllocator & timeDomainEXTAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_fragment_shading_rate ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR(
uint32_t * pFragmentShadingRateCount,
VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <
typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<PhysicalDeviceFragmentShadingRateKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<
std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<PhysicalDeviceFragmentShadingRateKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PhysicalDeviceFragmentShadingRateKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceFragmentShadingRateKHR>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<
std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
getFragmentShadingRatesKHR(
PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_tooling_info ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getToolPropertiesEXT( uint32_t * pToolCount,
VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT * pToolProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PhysicalDeviceToolPropertiesEXTAllocator = std::allocator<PhysicalDeviceToolPropertiesEXT>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<
std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PhysicalDeviceToolPropertiesEXTAllocator = std::allocator<PhysicalDeviceToolPropertiesEXT>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PhysicalDeviceToolPropertiesEXTAllocator,
typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceToolPropertiesEXT>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<
std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
getToolPropertiesEXT( PhysicalDeviceToolPropertiesEXTAllocator & physicalDeviceToolPropertiesEXTAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_NV_cooperative_matrix ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV(
uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = CooperativeMatrixPropertiesNVAllocator,
typename std::enable_if<std::is_same<typename B::value_type, CooperativeMatrixPropertiesNV>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_NV_coverage_reduction_mode ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getSupportedFramebufferMixedSamplesCombinationsNV(
uint32_t * pCombinationCount,
VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <
typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<FramebufferMixedSamplesCombinationNV>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<
std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
getSupportedFramebufferMixedSamplesCombinationsNV(
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <
typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<FramebufferMixedSamplesCombinationNV>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = FramebufferMixedSamplesCombinationNVAllocator,
typename std::enable_if<std::is_same<typename B::value_type, FramebufferMixedSamplesCombinationNV>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<
std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
getSupportedFramebufferMixedSamplesCombinationsNV(
FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_EXT_full_screen_exclusive ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
uint32_t * pPresentModeCount,
VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PresentModeKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
PresentModeKHRAllocator & presentModeKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_acquire_drm_display ===
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
acquireDrmDisplayEXT( int32_t drmFd,
VULKAN_HPP_NAMESPACE::DisplayKHR display,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type
acquireDrmDisplayEXT( int32_t drmFd,
VULKAN_HPP_NAMESPACE::DisplayKHR display,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getDrmDisplayEXT( int32_t drmFd,
uint32_t connectorId,
VULKAN_HPP_NAMESPACE::DisplayKHR * display,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
getDrmDisplayEXT( int32_t drmFd,
uint32_t connectorId,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
getDrmDisplayEXTUnique( int32_t drmFd,
uint32_t connectorId,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_NV_acquire_winrt_display ===
# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
getWinrtDisplayNV( uint32_t deviceRelativeId,
VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
getWinrtDisplayNVUnique( uint32_t deviceRelativeId,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
//=== VK_EXT_directfb_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex,
IDirectFB * dfb,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex,
IDirectFB & dfb,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_screen_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex,
struct _screen_window * window,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex,
struct _screen_window & window,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
{
return m_physicalDevice;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_physicalDevice != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_physicalDevice == VK_NULL_HANDLE;
}
private:
VkPhysicalDevice m_physicalDevice = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice ) == sizeof( VkPhysicalDevice ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevice>::value,
"PhysicalDevice is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED(
"vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePhysicalDevice>
{
using type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice>
{
using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice>
{
using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PhysicalDevice>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
#ifndef VULKAN_HPP_NO_SMART_HANDLE
class Instance;
template <typename Dispatch>
class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Instance, Dispatch>;
};
using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Instance, Dispatch>;
};
using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<SurfaceKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Instance, Dispatch>;
};
using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
class Instance
{
public:
using CType = VkInstance;
using NativeType = VkInstance;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
VULKAN_HPP_NAMESPACE::ObjectType::eInstance;
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;
public:
VULKAN_HPP_CONSTEXPR Instance() = default;
VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {}
#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
Instance & operator=( VkInstance instance ) VULKAN_HPP_NOEXCEPT
{
m_instance = instance;
return *this;
}
#endif
Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
m_instance = {};
return *this;
}
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Instance const & ) const = default;
#else
bool operator==( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_instance == rhs.m_instance;
}
bool operator!=( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_instance != rhs.m_instance;
}
bool operator<( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_instance < rhs.m_instance;
}
#endif
//=== VK_VERSION_1_0 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
enumeratePhysicalDevices( uint32_t * pPhysicalDeviceCount,
VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PhysicalDeviceAllocator = std::allocator<PhysicalDevice>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PhysicalDeviceAllocator = std::allocator<PhysicalDevice>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PhysicalDeviceAllocator,
typename std::enable_if<std::is_same<typename B::value_type, PhysicalDevice>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
PFN_vkVoidFunction
getProcAddr( const char * pName,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
PFN_vkVoidFunction
getProcAddr( const std::string & name,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_VERSION_1_1 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups(
uint32_t * pPhysicalDeviceGroupCount,
VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PhysicalDeviceGroupPropertiesAllocator,
typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void
destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_display ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR(
const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_USE_PLATFORM_XLIB_KHR )
//=== VK_KHR_xlib_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
#if defined( VK_USE_PLATFORM_XCB_KHR )
//=== VK_KHR_xcb_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_XCB_KHR*/
#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
//=== VK_KHR_wayland_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_KHR_android_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_win32_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_debug_report ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT(
const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT * pCallback,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type createDebugReportCallbackEXT(
const DebugReportCallbackCreateInfoEXT & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type
createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyDebugReportCallbackEXT(
VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
uint64_t object,
size_t location,
int32_t messageCode,
const char * pLayerPrefix,
const char * pMessage,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
uint64_t object,
size_t location,
int32_t messageCode,
const std::string & layerPrefix,
const std::string & message,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_USE_PLATFORM_GGP )
//=== VK_GGP_stream_descriptor_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP(
const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_GGP*/
#if defined( VK_USE_PLATFORM_VI_NN )
//=== VK_NN_vi_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_VI_NN*/
//=== VK_KHR_device_group_creation ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR(
uint32_t * pPhysicalDeviceGroupCount,
VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PhysicalDeviceGroupPropertiesAllocator,
typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
int>::type = 0>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_USE_PLATFORM_IOS_MVK )
//=== VK_MVK_ios_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_IOS_MVK*/
#if defined( VK_USE_PLATFORM_MACOS_MVK )
//=== VK_MVK_macos_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
//=== VK_EXT_debug_utils ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT(
const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT * pMessenger,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type createDebugUtilsMessengerEXT(
const DebugUtilsMessengerCreateInfoEXT & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type
createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroyDebugUtilsMessengerEXT(
VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes,
const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes,
const DebugUtilsMessengerCallbackDataEXT & callbackData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_USE_PLATFORM_FUCHSIA )
//=== VK_FUCHSIA_imagepipe_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA(
const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_FUCHSIA*/
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_headless_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
//=== VK_EXT_directfb_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
createDirectFBSurfaceEXTUnique( const DirectFBSurfaceCreateInfoEXT & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_screen_surface ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
createScreenSurfaceQNXUnique( const ScreenSurfaceCreateInfoQNX & createInfo,
Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const VULKAN_HPP_NOEXCEPT
{
return m_instance;
}
explicit operator bool() const VULKAN_HPP_NOEXCEPT
{
return m_instance != VK_NULL_HANDLE;
}
bool operator!() const VULKAN_HPP_NOEXCEPT
{
return m_instance == VK_NULL_HANDLE;
}
private:
VkInstance m_instance = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Instance ) == sizeof( VkInstance ),
"handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::Instance>::value,
"Instance is not nothrow_move_constructible!" );
template <>
struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eInstance>
{
using type = VULKAN_HPP_NAMESPACE::Instance;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eInstance>
{
using Type = VULKAN_HPP_NAMESPACE::Instance;
};
template <>
struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance>
{
using Type = VULKAN_HPP_NAMESPACE::Instance;
};
template <>
struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Instance>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
};
//=== VK_VERSION_1_0 ===
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch>
class UniqueHandleTraits<Instance, Dispatch>
{
public:
using deleter = ObjectDestroy<NoParent, Dispatch>;
};
using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo * pCreateInfo,
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
VULKAN_HPP_NAMESPACE::Instance * pInstance,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Instance>::type
createInstance( const InstanceCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
# ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>>::type
createInstanceUnique( const InstanceCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
# endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties(
const char * pLayerName,
uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
enumerateInstanceExtensionProperties( Optional<const std::string> layerName
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = ExtensionPropertiesAllocator,
typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
enumerateInstanceExtensionProperties( Optional<const std::string> layerName,
ExtensionPropertiesAllocator & extensionPropertiesAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result
enumerateInstanceLayerProperties( uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = LayerPropertiesAllocator,
typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type = 0>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_VERSION_1_1 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result enumerateInstanceVersion(
uint32_t * pApiVersion, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<uint32_t>::type
enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
} // namespace VULKAN_HPP_NAMESPACE
#endif
| [
"asuessenbach@nvidia.com"
] | asuessenbach@nvidia.com |
50515138deb3b7b551ca0b0bf6ce1f70ffd8ab85 | c1515b4b1d2f710bc8d9ff637a492bf22596ab07 | /src/pattern/dock_pattern_widget.cpp | 0a620a8e99ec805c28388d7dbf37fd0d397ee67b | [] | no_license | PeterZs/garment_design | eec0574c142665f664ea1883992e02d79b6690eb | 7fd7b280dba05c888404cf8db1b6ac4fd37defef | refs/heads/master | 2020-11-29T18:10:28.613057 | 2017-03-26T14:02:48 | 2017-03-26T14:02:48 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,186 | cpp | //
// Filename : dock_pattern_widget.cpp
// Author : Jamie Wither
// Purpose : The main widget of the dock for the Pattern module.
// Date of creation : 13 Dec 2005
//
///////////////////////////////////////////////////////////////////////////////
// LICENSE
#include <qcheckbox.h>
#include <qspinbox.h>
#include <qlineedit.h>
#include <qlistview.h>
#include <qslider.h>
#include "floatspinbox.h"
#include "config_pattern.h"
#include "config.h"
#include "dock_window.h"
#include "dock_pattern_widget.h"
DockPatternWidget::DockPatternWidget(DockWindow* parent, const char* name, WFlags fl) :
DockPatternWidgetBase(parent, name, fl)
{
_dw = parent;
_dw->config()->io()->setValue("display/pattern", true); // always start in pattern mode
listView1->setColumnText( 0, "Atlas name" );
listView1->addColumn( "Rows" );
listView1->addColumn( "Cols" );
listView1->clear();
listView1->insertItem ( new QListViewItem( listView1, "Load pattern file" ) );
updateConfig();
show();
}
DockPatternWidget::~DockPatternWidget()
{
}
void DockPatternWidget::updateConfig()
{
bool b1 = config::PATTERN_DISP_PATTERN;
float twist_degree_val = 90.0;
bool bmMesh = true;
bool bcMesh = false;
int atlas_cols = 2;
int atlas_rows = 2;
bool bSurface = true;
bool twistEnabled = false;
float ptf_val = 2.0/3.0;
float hcompress_top_val = 1.0;
float hcompress_bottom_val = 1.0;
float twist_factor_val = 4.0;
bool collision_enabled =false;
bool display_model = true;
int top_edges = 1;
int bottom_edges = 1;
int left_edges = 1;
int right_edges = 1;
bool e1,e2,e3,e4;
e1 = e2 = e3 = e4 = false;
int slide1 = 0;
int slide2 = 0;
if (_dw && _dw->config()) {
_dw->config()->io()->getValue("display/pattern", b1);
_dw->config()->io()->getValue("display/twist_degree_val", twist_degree_val);
_dw->config()->io()->getValue("display/model_mesh", bmMesh);
_dw->config()->io()->getValue("display/control_mesh", bcMesh);
_dw->config()->io()->getValue("display/atlas_cols", atlas_cols);
_dw->config()->io()->getValue("display/atlas_rows", atlas_rows);
_dw->config()->io()->getValue("display/buckling_surface", bSurface);
_dw->config()->io()->getValue("display/twist_enabled", twistEnabled);
_dw->config()->io()->getValue("display/ptf_val", ptf_val);
_dw->config()->io()->getValue("display/hcompress_top_val", hcompress_top_val);
_dw->config()->io()->getValue("display/hcompress_bottom_val", hcompress_bottom_val);
_dw->config()->io()->getValue("display/twist_factor_val", twist_factor_val);
_dw->config()->io()->getValue("display/collision_detection_enabled", collision_enabled);
_dw->config()->io()->getValue("display/model", display_model);
_dw->config()->io()->getValue("display/top_edges", top_edges);
_dw->config()->io()->getValue("display/bottom_edges", bottom_edges);
_dw->config()->io()->getValue("display/left_edges", left_edges);
_dw->config()->io()->getValue("display/right_edges", right_edges);
_dw->config()->io()->getValue("display/effect1", e1);
_dw->config()->io()->getValue("display/effect2", e2);
_dw->config()->io()->getValue("display/effect3", e3);
_dw->config()->io()->getValue("display/effect4", e4);
_dw->config()->io()->getValue("display/slider1", slide1);
_dw->config()->io()->getValue("display/slider2", slide2);
}
// Block signals in order not to trigger any callback.
patternCheckBox->blockSignals(true);
patternCheckBox->setChecked(b1);
patternCheckBox->blockSignals(false);
twistSpinBox->blockSignals(true);
twistSpinBox->setValue(twist_degree_val);
twistSpinBox->blockSignals(false);
twistFactorFloatSpinBox->blockSignals(true);
twistFactorFloatSpinBox->setValue(twist_factor_val);
twistFactorFloatSpinBox->blockSignals(false);
hCompressTopFloatSpinBox->blockSignals(true);
hCompressTopFloatSpinBox->setValue(hcompress_top_val);
hCompressTopFloatSpinBox->setLineStep(0.1);
hCompressTopFloatSpinBox->blockSignals(false);
hCompressBottomFloatSpinBox->blockSignals(true);
hCompressBottomFloatSpinBox->setValue(hcompress_bottom_val);
hCompressBottomFloatSpinBox->setLineStep(0.1);
hCompressBottomFloatSpinBox->blockSignals(false);
patchTangentFactorFloatSpinBox->blockSignals(true);
patchTangentFactorFloatSpinBox->setValue(ptf_val);
patchTangentFactorFloatSpinBox->setLineStep(0.05);
patchTangentFactorFloatSpinBox->blockSignals(false);
atlasColsSpinBox->blockSignals(true);
atlasColsSpinBox->setValue(atlas_cols);
atlasColsSpinBox->blockSignals(false);
atlasRowsSpinBox->blockSignals(true);
atlasRowsSpinBox->setValue(atlas_rows);
atlasRowsSpinBox->blockSignals(false);
leftEdgesSpinBox->blockSignals(true);
leftEdgesSpinBox->setValue(left_edges);
leftEdgesSpinBox->blockSignals(false);
rightEdgesSpinBox->blockSignals(true);
rightEdgesSpinBox->setValue(right_edges);
rightEdgesSpinBox->blockSignals(false);
topEdgesSpinBox->blockSignals(true);
topEdgesSpinBox->setValue(top_edges);
topEdgesSpinBox->blockSignals(false);
bottomEdgesSpinBox->blockSignals(true);
bottomEdgesSpinBox->setValue(bottom_edges);
bottomEdgesSpinBox->blockSignals(false);
modelMeshCheckBox->blockSignals(true);
modelMeshCheckBox->setChecked(bmMesh);
modelMeshCheckBox->blockSignals(false);
controlMeshCheckBox->blockSignals(true);
controlMeshCheckBox->setChecked(bcMesh);
controlMeshCheckBox->blockSignals(false);
bSurfaceCheckBox->blockSignals(true);
bSurfaceCheckBox->setChecked(bSurface);
bSurfaceCheckBox->blockSignals(false);
twistEnabledCheckBox->blockSignals(true);
twistEnabledCheckBox->setChecked(twistEnabled);
twistEnabledCheckBox->blockSignals(false);
collisionEnabledCheckBox->blockSignals(true);
collisionEnabledCheckBox->setChecked(collision_enabled);
collisionEnabledCheckBox->blockSignals(false);
displayModelCheckBox->blockSignals(true);
displayModelCheckBox->setChecked(display_model);
displayModelCheckBox->blockSignals(false);
effect1CheckBox->blockSignals(true);
effect1CheckBox->setChecked(e1);
effect1CheckBox->blockSignals(false);
effect2CheckBox->blockSignals(true);
effect2CheckBox->setChecked(e2);
effect2CheckBox->blockSignals(false);
effect3CheckBox->blockSignals(true);
effect3CheckBox->setChecked(e3);
effect3CheckBox->blockSignals(false);
effect4CheckBox->blockSignals(true);
effect4CheckBox->setChecked(e4);
effect4CheckBox->blockSignals(false);
slider1->blockSignals(true);
slider1->setValue(slide1);
slider1->blockSignals(false);
slider2->blockSignals(true);
slider2->setValue(slide2);
slider2->blockSignals(false);
}
void DockPatternWidget::patternCheckBox_toggled(bool b)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/pattern", b);
_dw->config()->io()->setValue("display/type_changed", true);
_dw->configUpdated();
}
void DockPatternWidget::switchAtlas(QListViewItem* pItem)
{
//(Pattern_dw->choose
// FIXME tied in strings
if (!_dw || !_dw->config())
return;
if(!pItem) return;
_dw->config()->io()->setValue("display/atlas_name", pItem->text(0) );
_dw->config()->io()->setValue("display/atlas_changed", true);
_dw->configUpdated();
}
void DockPatternWidget::controlMeshCheckBox_toggled(bool b)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/control_mesh", b);
_dw->config()->io()->setValue("display/redraw", true);
_dw->configUpdated();
}
void DockPatternWidget::Redraw_clicked()
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/redraw", true);
_dw->configUpdated();
}
void DockPatternWidget::twistSpinBox_valueChanged(float v)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/twist_degree_val", v);
}
void DockPatternWidget::twistFactorFloatSpinBox_valueChanged(float v)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/twist_factor_val", v);
}
void DockPatternWidget::hCompressTopFloatSpinBox_valueChanged(float v)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/hcompress_top_val", v);
}
void DockPatternWidget::hCompressBottomFloatSpinBox_valueChanged(float v)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/hcompress_bottom_val", v);
}
void DockPatternWidget::patchTangentFactorFloatSpinBox_valueChanged(float v)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/ptf_val", v);
}
void DockPatternWidget::modelMeshCheckBox_toggled(bool b)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/model_mesh", b);
_dw->config()->io()->setValue("display/redraw", true);
_dw->configUpdated();
}
void DockPatternWidget::atlasColsSpinBox_valueChanged(int val)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/atlas_cols", val);
_dw->config()->io()->setValue("display/atlas_cols_changed", true);
_dw->configUpdated();
}
void DockPatternWidget::atlasRowsSpinBox_valueChanged(int val)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/atlas_rows", val);
_dw->config()->io()->setValue("display/atlas_rows_changed", true);
_dw->configUpdated();
}
void DockPatternWidget::bSurfaceCheckBox_toggled(bool b)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/buckling_surface", b);
_dw->config()->io()->setValue("display/redraw", true);
_dw->configUpdated();
}
void DockPatternWidget::twistEnabledCheckBox_toggled(bool b)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/twist_enabled", b);
_dw->config()->io()->setValue("display/redraw", true);
_dw->configUpdated();
}
void DockPatternWidget::collisionEnabledCheckBox_toggled(bool b)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/collision_detection_enabled", b);
_dw->config()->io()->setValue("display/redraw", true);
_dw->configUpdated();
}
void DockPatternWidget::displayModelCheckBox_toggled(bool b)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/model", b);
_dw->config()->io()->setValue("display/redraw", true);
_dw->configUpdated();
}
void DockPatternWidget::axisAlignButton_clicked()
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/axis_align_clicked", true);
_dw->configUpdated();
}
void DockPatternWidget::topEdgesSpinBox_valueChanged(int val)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/top_edges", val);
_dw->config()->io()->setValue("display/edges_required_changed", true);
_dw->configUpdated();
}
void DockPatternWidget::bottomEdgesSpinBox_valueChanged(int val)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/bottom_edges", val);
_dw->config()->io()->setValue("display/edges_required_changed", true);
_dw->configUpdated();
}
void DockPatternWidget::leftEdgesSpinBox_valueChanged(int val)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/left_edges", val);
_dw->config()->io()->setValue("display/edges_required_changed", true);
_dw->configUpdated();
}
void DockPatternWidget::rightEdgesSpinBox_valueChanged(int val)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/right_edges", val);
_dw->config()->io()->setValue("display/edges_required_changed", true);
_dw->configUpdated();
}
void DockPatternWidget::effect1CheckBox_toggled(bool b)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/effect1", b);
_dw->config()->io()->setValue("display/redraw", true);
_dw->configUpdated();
}
void DockPatternWidget::effect2CheckBox_toggled(bool b)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/effect2", b);
_dw->config()->io()->setValue("display/redraw", true);
_dw->configUpdated();
}
void DockPatternWidget::effect3CheckBox_toggled(bool b)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/effect3", b);
_dw->config()->io()->setValue("display/redraw", true);
_dw->configUpdated();
}
void DockPatternWidget::effect4CheckBox_toggled(bool b)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/effect4", b);
_dw->config()->io()->setValue("display/redraw", true);
_dw->configUpdated();
}
void DockPatternWidget::slider1_valueChanged(int i)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/slider1", i);
_dw->config()->io()->setValue("display/redraw", true);
_dw->configUpdated();
}
void DockPatternWidget::slider2_valueChanged(int i)
{
if (!_dw || !_dw->config())
return;
_dw->config()->io()->setValue("display/slider2", i);
_dw->config()->io()->setValue("display/redraw", true);
_dw->configUpdated();
}
| [
"edward2414@gmail.com"
] | edward2414@gmail.com |
734169c1372d48441eac5c09e301ea93859caf79 | c7350c770088fb682d400fe646b9801765017eed | /src/SdsDustSensor.cpp | 16145d98be917376d3740bbfe830e9c280f57f91 | [
"MIT"
] | permissive | lewapek/sds-dust-sensors-arduino-library | addd89a157910f19bf2bfe6c0e467dfe330ffb33 | ed5917d324cbee938fa61e7c2d301b63d05ef545 | refs/heads/master | 2022-02-28T20:34:27.550513 | 2022-02-14T18:41:03 | 2022-02-14T18:41:03 | 131,445,447 | 71 | 25 | MIT | 2022-02-16T09:38:11 | 2018-04-28T21:30:11 | C++ | UTF-8 | C++ | false | false | 3,163 | cpp | #include "SdsDustSensor.h"
void SdsDustSensor::write(const Command &command) {
for (int i = 0; i < Command::length; ++i) {
sdsStream->write(command.bytes[i]);
#ifdef __DEBUG_SDS_DUST_SENSOR__
Serial.print("|");
Serial.print(command.bytes[i], HEX);
#endif
}
#ifdef __DEBUG_SDS_DUST_SENSOR__
Serial.println("| <- written bytes");
#endif
delay(500);
}
Status SdsDustSensor::readIntoBytes(byte responseId) {
int checksum = 0;
int readBytesQuantity = 0;
while (sdsStream->available() >= Result::lenght - readBytesQuantity) {
byte readByte = sdsStream->read();
response[readBytesQuantity] = readByte;
#ifdef __DEBUG_SDS_DUST_SENSOR__
Serial.print("|");
Serial.print(readByte, HEX);
#endif
++readBytesQuantity;
switch (readBytesQuantity) {
case 1:
if (readByte != 0xAA) {
#ifdef __DEBUG_SDS_DUST_SENSOR__
Serial.println("| <- read bytes with invalid head error");
#endif
return Status::InvalidHead;
}
break;
case 2:
if (readByte != responseId) {
#ifdef __DEBUG_SDS_DUST_SENSOR__
Serial.println("| <- read bytes with invalid response id");
#endif
return Status::InvalidResponseId;
}
break;
case 3 ... 8:
checksum += readByte;
break;
case 9:
if (readByte != checksum % 256) {
#ifdef __DEBUG_SDS_DUST_SENSOR__
Serial.println("| <- read bytes with invalid checksum");
#endif
return Status::InvalidChecksum;
}
break;
case 10:
if (readByte != 0xAB) {
#ifdef __DEBUG_SDS_DUST_SENSOR__
Serial.println("| <- read bytes with invalid tail");
#endif
return Status::InvalidTail;
}
break;
}
if (readBytesQuantity == Result::lenght) {
#ifdef __DEBUG_SDS_DUST_SENSOR__
Serial.println("| <- read bytes with success");
#endif
return Status::Ok;
}
yield();
}
#ifdef __DEBUG_SDS_DUST_SENSOR__
Serial.println("| <- read bytes with no more available");
#endif
return Status::NotAvailable;
}
void SdsDustSensor::flushStream() {
while (sdsStream->available() > 0) {
#ifdef __DEBUG_SDS_DUST_SENSOR__
Serial.print("|");
Serial.print(sdsStream->read(), HEX);
Serial.println("| <- omitted byte");
#else
sdsStream->read();
#endif
}
}
Status SdsDustSensor::retryRead(byte responseId) {
Status status = readIntoBytes(responseId);
for (int i = 0; status == Status::NotAvailable && i < maxRetriesNotAvailable; ++i) {
#ifdef __DEBUG_SDS_DUST_SENSOR__
Serial.print("Retry #");
Serial.print(i);
Serial.println(" due to not available response");
#endif
delay(retryDelayMs);
status = readIntoBytes(responseId);
}
for (int i = 2; status == Status::InvalidHead && i < Result::lenght; ++i) {
#ifdef __DEBUG_SDS_DUST_SENSOR__
Serial.print("Retry #");
Serial.print(i - 2);
Serial.println(" due to invalid response head");
#endif
status = readIntoBytes(responseId);
}
return status;
}
| [
"lewapek@gmail.com"
] | lewapek@gmail.com |
faa58e267d0920c88998d7507c84cc1f60d22c43 | 3b40374043ee732d8e45bac5711f56b9146b347f | /10/105.cpp | 3e0572be5ead98c9fab1a3be5d59a1821aa795a7 | [] | no_license | hpsdy/c-plus | 01e2681ddd410a0f71a93e183d610a355d461313 | 9077aff1c62136281777a0e03ab2981aa0330fbe | refs/heads/master | 2021-01-24T04:08:09.042744 | 2018-11-03T04:13:07 | 2018-11-03T04:13:07 | 122,922,744 | 0 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 311 | cpp | #include"head.h"
int main(){
char p[] = {'a','b','\0'};
char cp[] = {*strdup(&p[0]),*strdup(&p[1]),*strdup(&p[2])};
char pp[] = {p[0],p[1],p[2]};
cout<<p<<endl;
cout<<cp<<endl;
cout<<pp<<endl;
cout<<equal(begin(p),end(p),begin(cp))<<endl;
cout<<equal(begin(p),end(p),begin(pp))<<endl;
return 0;
}
| [
"1036474541@qq.com"
] | 1036474541@qq.com |
b5ea1eec6f0ccf12ab710f0c3eaf28d4c9badc73 | 81bfc38f9c6fc8f99295dbf7b712bce7ec6e2cb2 | /fizz/server/ServerProtocol.cpp | 8fc5380651285b91e07ddd702bbc62f6b144692e | [
"BSD-3-Clause"
] | permissive | karthikbhargavan/fizz | a058abfda79f6bd5b00173d753810ceddfd28369 | 0d57338a2ff5e3a57ea0aaf1d9c96a8a04a07164 | refs/heads/master | 2020-04-07T14:08:10.197743 | 2018-11-20T05:10:55 | 2018-11-20T05:18:25 | 158,434,990 | 0 | 0 | NOASSERTION | 2018-11-20T18:36:04 | 2018-11-20T18:36:03 | null | UTF-8 | C++ | false | false | 71,342 | cpp | /*
* Copyright (c) 2018-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <fizz/server/ServerProtocol.h>
#include <fizz/crypto/Utils.h>
#include <fizz/protocol/CertificateVerifier.h>
#include <fizz/protocol/Protocol.h>
#include <fizz/protocol/StateMachine.h>
#include <fizz/record/Extensions.h>
#include <fizz/record/PlaintextRecordLayer.h>
#include <fizz/server/AsyncSelfCert.h>
#include <fizz/server/Negotiator.h>
#include <fizz/server/ReplayCache.h>
#include <folly/Overload.h>
#include <algorithm>
using folly::Future;
using folly::Optional;
using namespace fizz::server;
using namespace fizz::server::detail;
// We only ever use the first PSK sent.
static constexpr uint16_t kPskIndex = 0;
namespace fizz {
namespace sm {
FIZZ_DECLARE_EVENT_HANDLER(
ServerTypes,
StateEnum::Uninitialized,
Event::Accept,
StateEnum::ExpectingClientHello);
FIZZ_DECLARE_EVENT_HANDLER(
ServerTypes,
StateEnum::ExpectingClientHello,
Event::ClientHello,
StateEnum::ExpectingClientHello,
StateEnum::ExpectingCertificate,
StateEnum::ExpectingFinished,
StateEnum::AcceptingEarlyData,
StateEnum::Error);
FIZZ_DECLARE_EVENT_HANDLER(
ServerTypes,
StateEnum::AcceptingEarlyData,
Event::AppData,
StateEnum::Error);
FIZZ_DECLARE_EVENT_HANDLER(
ServerTypes,
StateEnum::AcceptingEarlyData,
Event::AppWrite,
StateEnum::Error);
FIZZ_DECLARE_EVENT_HANDLER(
ServerTypes,
StateEnum::AcceptingEarlyData,
Event::EndOfEarlyData,
StateEnum::ExpectingFinished);
FIZZ_DECLARE_EVENT_HANDLER(
ServerTypes,
StateEnum::ExpectingCertificate,
Event::Certificate,
StateEnum::ExpectingCertificateVerify,
StateEnum::ExpectingFinished)
FIZZ_DECLARE_EVENT_HANDLER(
ServerTypes,
StateEnum::ExpectingCertificateVerify,
Event::CertificateVerify,
StateEnum::ExpectingFinished);
FIZZ_DECLARE_EVENT_HANDLER(
ServerTypes,
StateEnum::ExpectingFinished,
Event::AppWrite,
StateEnum::Error);
FIZZ_DECLARE_EVENT_HANDLER(
ServerTypes,
StateEnum::ExpectingFinished,
Event::Finished,
StateEnum::AcceptingData);
FIZZ_DECLARE_EVENT_HANDLER(
ServerTypes,
StateEnum::AcceptingData,
Event::WriteNewSessionTicket,
StateEnum::Error);
FIZZ_DECLARE_EVENT_HANDLER(
ServerTypes,
StateEnum::AcceptingData,
Event::AppData,
StateEnum::Error);
FIZZ_DECLARE_EVENT_HANDLER(
ServerTypes,
StateEnum::AcceptingData,
Event::AppWrite,
StateEnum::Error);
FIZZ_DECLARE_EVENT_HANDLER(
ServerTypes,
StateEnum::AcceptingData,
Event::KeyUpdate,
StateEnum::AcceptingData);
} // namespace sm
namespace server {
AsyncActions ServerStateMachine::processAccept(
const State& state,
folly::Executor* executor,
std::shared_ptr<const FizzServerContext> context,
const std::shared_ptr<ServerExtensions>& extensions) {
Accept accept;
accept.executor = executor;
accept.context = std::move(context);
accept.extensions = extensions;
return detail::processEvent(state, std::move(accept));
}
AsyncActions ServerStateMachine::processSocketData(
const State& state,
folly::IOBufQueue& buf) {
try {
if (!state.readRecordLayer()) {
return detail::handleError(
state,
ReportError("attempting to process data without record layer"),
folly::none);
}
auto param = state.readRecordLayer()->readEvent(buf);
if (!param.hasValue()) {
return actions(WaitForData());
}
return detail::processEvent(state, std::move(*param));
} catch (const std::exception& e) {
return detail::handleError(
state,
ReportError(folly::exception_wrapper(std::current_exception(), e)),
AlertDescription::decode_error);
}
}
AsyncActions ServerStateMachine::processWriteNewSessionTicket(
const State& state,
WriteNewSessionTicket write) {
return detail::processEvent(state, std::move(write));
}
AsyncActions ServerStateMachine::processAppWrite(
const State& state,
AppWrite write) {
return detail::processEvent(state, std::move(write));
}
AsyncActions ServerStateMachine::processEarlyAppWrite(
const State& state,
EarlyAppWrite write) {
return detail::processEvent(state, std::move(write));
}
Actions ServerStateMachine::processAppClose(const State& state) {
return detail::handleAppClose(state);
}
namespace detail {
AsyncActions processEvent(const State& state, Param param) {
auto event = boost::apply_visitor(EventVisitor(), param);
// We can have an exception directly in the handler or in a future so we need
// to handle both types.
try {
auto actions = sm::StateMachine<ServerTypes>::getHandler(
state.state(), event)(state, std::move(param));
return folly::variant_match(
actions,
[&state](folly::Future<Actions>& futureActions) -> AsyncActions {
return std::move(futureActions)
.onError([&state](folly::exception_wrapper ew) {
auto ex = ew.get_exception<FizzException>();
if (ex) {
return detail::handleError(
state, ReportError(std::move(ew)), ex->getAlert());
}
return detail::handleError(
state,
ReportError(std::move(ew)),
AlertDescription::unexpected_message);
});
},
[](Actions& immediateActions) -> AsyncActions {
return std::move(immediateActions);
});
} catch (const FizzException& e) {
return detail::handleError(
state,
ReportError(folly::exception_wrapper(std::current_exception(), e)),
e.getAlert());
} catch (const std::exception& e) {
return detail::handleError(
state,
ReportError(folly::exception_wrapper(std::current_exception(), e)),
AlertDescription::unexpected_message);
}
}
Actions handleError(
const State& state,
ReportError error,
Optional<AlertDescription> alertDesc) {
if (state.state() == StateEnum::Error) {
return actions();
}
auto transition = [](State& newState) {
newState.state() = StateEnum::Error;
newState.writeRecordLayer() = nullptr;
newState.readRecordLayer() = nullptr;
};
if (alertDesc && state.writeRecordLayer()) {
Alert alert(*alertDesc);
WriteToSocket write;
write.contents.emplace_back(
state.writeRecordLayer()->writeAlert(std::move(alert)));
return actions(std::move(transition), std::move(write), std::move(error));
} else {
return actions(std::move(transition), std::move(error));
}
}
Actions handleAppClose(const State& state) {
auto transition = [](State& newState) {
newState.state() = StateEnum::Error;
newState.writeRecordLayer() = nullptr;
newState.readRecordLayer() = nullptr;
};
if (state.writeRecordLayer()) {
Alert alert(AlertDescription::close_notify);
WriteToSocket write;
write.contents.emplace_back(
state.writeRecordLayer()->writeAlert(std::move(alert)));
return actions(std::move(transition), std::move(write));
} else {
return actions(std::move(transition));
}
}
Actions handleInvalidEvent(const State& state, Event event, Param param) {
if (event == Event::Alert) {
auto& alert = boost::get<Alert>(param);
throw FizzException(
folly::to<std::string>(
"received alert: ",
toString(alert.description),
", in state ",
toString(state.state())),
folly::none);
} else {
throw FizzException(
folly::to<std::string>(
"invalid event: ",
toString(event),
", in state ",
toString(state.state())),
AlertDescription::unexpected_message);
}
}
} // namespace detail
} // namespace server
namespace sm {
AsyncActions
EventHandler<ServerTypes, StateEnum::Uninitialized, Event::Accept>::handle(
const State& /*state*/,
Param param) {
auto& accept = boost::get<Accept>(param);
auto factory = accept.context->getFactory();
auto readRecordLayer = factory->makePlaintextReadRecordLayer();
auto writeRecordLayer = factory->makePlaintextWriteRecordLayer();
auto handshakeLogging = std::make_unique<HandshakeLogging>();
return actions(
[executor = accept.executor,
rrl = std::move(readRecordLayer),
wrl = std::move(writeRecordLayer),
context = std::move(accept.context),
handshakeLogging = std::move(handshakeLogging),
extensions = accept.extensions](State& newState) mutable {
newState.executor() = executor;
newState.context() = std::move(context);
newState.readRecordLayer() = std::move(rrl);
newState.writeRecordLayer() = std::move(wrl);
newState.handshakeLogging() = std::move(handshakeLogging);
newState.extensions() = std::move(extensions);
},
&Transition<StateEnum::ExpectingClientHello>);
}
static void addHandshakeLogging(const State& state, const ClientHello& chlo) {
if (state.handshakeLogging()) {
state.handshakeLogging()->clientLegacyVersion = chlo.legacy_version;
auto supportedVersions = getExtension<SupportedVersions>(chlo.extensions);
if (supportedVersions) {
state.handshakeLogging()->clientSupportedVersions =
supportedVersions->versions;
}
state.handshakeLogging()->clientCiphers = chlo.cipher_suites;
state.handshakeLogging()->clientExtensions.clear();
for (const auto& extension : chlo.extensions) {
state.handshakeLogging()->clientExtensions.push_back(
extension.extension_type);
}
auto plaintextReadRecord =
dynamic_cast<PlaintextReadRecordLayer*>(state.readRecordLayer());
if (plaintextReadRecord) {
state.handshakeLogging()->clientRecordVersion =
plaintextReadRecord->getReceivedRecordVersion();
}
auto sni = getExtension<ServerNameList>(chlo.extensions);
if (sni && !sni->server_name_list.empty()) {
state.handshakeLogging()->clientSni = sni->server_name_list.front()
.hostname->moveToFbString()
.toStdString();
}
auto supportedGroups = getExtension<SupportedGroups>(chlo.extensions);
if (supportedGroups) {
state.handshakeLogging()->clientSupportedGroups =
std::move(supportedGroups->named_group_list);
}
auto keyShare = getExtension<ClientKeyShare>(chlo.extensions);
if (keyShare && !state.handshakeLogging()->clientKeyShares) {
std::vector<NamedGroup> shares;
for (const auto& entry : keyShare->client_shares) {
shares.push_back(entry.group);
}
state.handshakeLogging()->clientKeyShares = std::move(shares);
}
auto exchangeModes = getExtension<PskKeyExchangeModes>(chlo.extensions);
if (exchangeModes) {
state.handshakeLogging()->clientKeyExchangeModes =
std::move(exchangeModes->modes);
}
auto clientSigSchemes = getExtension<SignatureAlgorithms>(chlo.extensions);
if (clientSigSchemes) {
state.handshakeLogging()->clientSignatureAlgorithms =
std::move(clientSigSchemes->supported_signature_algorithms);
}
state.handshakeLogging()->clientSessionIdSent =
chlo.legacy_session_id && !chlo.legacy_session_id->empty();
state.handshakeLogging()->clientRandom = chlo.random;
}
}
static void validateClientHello(const ClientHello& chlo) {
if (chlo.legacy_compression_methods.size() != 1 ||
chlo.legacy_compression_methods.front() != 0x00) {
throw FizzException(
"client compression methods not exactly NULL",
AlertDescription::illegal_parameter);
}
Protocol::checkDuplicateExtensions(chlo.extensions);
}
static Optional<ProtocolVersion> negotiateVersion(
const ClientHello& chlo,
const std::vector<ProtocolVersion>& versions) {
const auto& clientVersions = getExtension<SupportedVersions>(chlo.extensions);
if (!clientVersions) {
return folly::none;
}
auto version = negotiate(versions, clientVersions->versions);
if (!version) {
return folly::none;
}
return version;
}
static Optional<CookieState> getCookieState(
const ClientHello& chlo,
ProtocolVersion version,
CipherSuite cipher,
const CookieCipher* cookieCipher) {
auto cookieExt = getExtension<Cookie>(chlo.extensions);
if (!cookieExt) {
return folly::none;
}
// If the client sent a cookie we can't use we have to consider it a fatal
// error since we can't reconstruct the handshake transcript.
if (!cookieCipher) {
throw FizzException(
"no cookie cipher", AlertDescription::unsupported_extension);
}
auto cookieState = cookieCipher->decrypt(std::move(cookieExt->cookie));
if (!cookieState) {
throw FizzException(
"could not decrypt cookie", AlertDescription::decrypt_error);
}
if (cookieState->version != version) {
throw FizzException(
"version mismatch with cookie", AlertDescription::protocol_version);
}
if (cookieState->cipher != cipher) {
throw FizzException(
"cipher mismatch with cookie", AlertDescription::handshake_failure);
}
return cookieState;
}
namespace {
struct ResumptionStateResult {
explicit ResumptionStateResult(
Future<std::pair<PskType, Optional<ResumptionState>>> futureResStateArg,
Optional<PskKeyExchangeMode> pskModeArg = folly::none,
Optional<uint32_t> obfuscatedAgeArg = folly::none)
: futureResState(std::move(futureResStateArg)),
pskMode(std::move(pskModeArg)),
obfuscatedAge(std::move(obfuscatedAgeArg)) {}
Future<std::pair<PskType, Optional<ResumptionState>>> futureResState;
Optional<PskKeyExchangeMode> pskMode;
Optional<uint32_t> obfuscatedAge;
};
} // namespace
static ResumptionStateResult getResumptionState(
const ClientHello& chlo,
const TicketCipher* ticketCipher,
const std::vector<PskKeyExchangeMode>& supportedModes) {
auto psks = getExtension<ClientPresharedKey>(chlo.extensions);
auto clientModes = getExtension<PskKeyExchangeModes>(chlo.extensions);
if (psks && !clientModes) {
throw FizzException("no psk modes", AlertDescription::missing_extension);
}
Optional<PskKeyExchangeMode> pskMode;
if (clientModes) {
pskMode = negotiate(supportedModes, clientModes->modes);
}
if (!psks && !pskMode) {
return ResumptionStateResult(
std::make_pair(PskType::NotSupported, folly::none));
} else if (!psks || psks->identities.size() <= kPskIndex) {
return ResumptionStateResult(
std::make_pair(PskType::NotAttempted, folly::none));
} else if (!ticketCipher) {
VLOG(8) << "No ticket cipher, rejecting PSK.";
return ResumptionStateResult(
std::make_pair(PskType::Rejected, folly::none));
} else if (!pskMode) {
VLOG(8) << "No psk mode match, rejecting PSK.";
return ResumptionStateResult(
std::make_pair(PskType::Rejected, folly::none));
} else {
const auto& ident = psks->identities[kPskIndex].psk_identity;
return ResumptionStateResult(
ticketCipher->decrypt(ident->clone()),
pskMode,
psks->identities[kPskIndex].obfuscated_ticket_age);
}
}
Future<ReplayCacheResult> getReplayCacheResult(
const ClientHello& chlo,
bool zeroRttEnabled,
ReplayCache* replayCache) {
if (!zeroRttEnabled || !replayCache ||
!getExtension<ClientEarlyData>(chlo.extensions)) {
return ReplayCacheResult::NotChecked;
}
return replayCache->check(folly::range(chlo.random));
}
static bool validateResumptionState(
const ResumptionState& resState,
PskKeyExchangeMode /* mode */,
ProtocolVersion version,
CipherSuite cipher) {
if (resState.version != version) {
VLOG(8) << "Protocol version mismatch, rejecting PSK.";
return false;
}
if (getHashFunction(resState.cipher) != getHashFunction(cipher)) {
VLOG(8) << "Hash mismatch, rejecting PSK.";
return false;
}
return true;
}
static CipherSuite negotiateCipher(
const ClientHello& chlo,
const std::vector<std::vector<CipherSuite>>& supportedCiphers) {
auto cipher = negotiate(supportedCiphers, chlo.cipher_suites);
if (!cipher) {
throw FizzException("no cipher match", AlertDescription::handshake_failure);
}
return *cipher;
}
/*
* Sets up a KeyScheduler and HandshakeContext for the connection. The
* KeyScheduler will have the early secret derived if applicable, and the
* ClientHello will be added to the HandshakeContext. This also verifies the
* PSK binder if applicable.
*
* If the passed in handshakeContext is non-null it is used instead of a new
* context. This is used after a HelloRetryRequest when there is already a
* handshake transcript before the current ClientHello.
*/
static std::
pair<std::unique_ptr<KeyScheduler>, std::unique_ptr<HandshakeContext>>
setupSchedulerAndContext(
const Factory& factory,
CipherSuite cipher,
const ClientHello& chlo,
const Optional<ResumptionState>& resState,
const Optional<CookieState>& cookieState,
PskType pskType,
std::unique_ptr<HandshakeContext> handshakeContext,
ProtocolVersion /*version*/) {
auto scheduler = factory.makeKeyScheduler(cipher);
if (cookieState) {
if (handshakeContext) {
throw FizzException(
"cookie after statefull hrr", AlertDescription::illegal_parameter);
}
handshakeContext = factory.makeHandshakeContext(cipher);
message_hash chloHash;
chloHash.hash = cookieState->chloHash->clone();
handshakeContext->appendToTranscript(encodeHandshake(std::move(chloHash)));
auto cookie = getExtension<Cookie>(chlo.extensions);
handshakeContext->appendToTranscript(getStatelessHelloRetryRequest(
cookieState->version,
cookieState->cipher,
cookieState->group,
std::move(cookie->cookie)));
} else if (!handshakeContext) {
handshakeContext = factory.makeHandshakeContext(cipher);
}
if (resState) {
scheduler->deriveEarlySecret(resState->resumptionSecret->coalesce());
auto binderKey = scheduler->getSecret(
pskType == PskType::External ? EarlySecrets::ExternalPskBinder
: EarlySecrets::ResumptionPskBinder,
handshakeContext->getBlankContext());
folly::IOBufQueue chloQueue(folly::IOBufQueue::cacheChainLength());
chloQueue.append((*chlo.originalEncoding)->clone());
auto chloPrefix =
chloQueue.split(chloQueue.chainLength() - getBinderLength(chlo));
handshakeContext->appendToTranscript(chloPrefix);
const auto& psks = getExtension<ClientPresharedKey>(chlo.extensions);
if (!psks || psks->binders.size() <= kPskIndex) {
throw FizzException("no binders", AlertDescription::illegal_parameter);
}
auto expectedBinder =
handshakeContext->getFinishedData(folly::range(binderKey));
if (!CryptoUtils::equal(
expectedBinder->coalesce(),
psks->binders[kPskIndex].binder->coalesce())) {
throw FizzException(
"binder does not match", AlertDescription::bad_record_mac);
}
handshakeContext->appendToTranscript(chloQueue.move());
return std::make_pair(std::move(scheduler), std::move(handshakeContext));
} else {
handshakeContext->appendToTranscript(*chlo.originalEncoding);
return std::make_pair(std::move(scheduler), std::move(handshakeContext));
}
}
static void validateGroups(const std::vector<KeyShareEntry>& client_shares) {
std::set<NamedGroup> setOfNamedGroups;
for (const auto& share : client_shares) {
if (setOfNamedGroups.find(share.group) != setOfNamedGroups.end()) {
throw FizzException(
"duplicate client key share", AlertDescription::illegal_parameter);
}
setOfNamedGroups.insert(share.group);
}
}
static std::tuple<NamedGroup, Optional<Buf>> negotiateGroup(
ProtocolVersion version,
const ClientHello& chlo,
const std::vector<NamedGroup>& supportedGroups) {
auto groups = getExtension<SupportedGroups>(chlo.extensions);
if (!groups) {
throw FizzException("no named groups", AlertDescription::missing_extension);
}
auto group = negotiate(supportedGroups, groups->named_group_list);
if (!group) {
throw FizzException("no group match", AlertDescription::handshake_failure);
}
auto clientShares = getExtension<ClientKeyShare>(chlo.extensions);
if (!clientShares) {
throw FizzException(
"no client shares", AlertDescription::missing_extension);
}
auto realVersion = getRealDraftVersion(version);
if (realVersion == ProtocolVersion::tls_1_3_20 ||
realVersion == ProtocolVersion::tls_1_3_21 ||
realVersion == ProtocolVersion::tls_1_3_22) {
if (!clientShares->preDraft23) {
throw FizzException(
"post-23 client share", AlertDescription::illegal_parameter);
}
} else {
if (clientShares->preDraft23) {
throw FizzException(
"pre-23 client share", AlertDescription::illegal_parameter);
}
}
validateGroups(clientShares->client_shares);
for (const auto& share : clientShares->client_shares) {
if (share.group == *group) {
return std::make_tuple(*group, share.key_exchange->clone());
}
}
return std::make_tuple(*group, folly::none);
}
static Buf doKex(
const Factory& factory,
NamedGroup group,
const Buf& clientShare,
KeyScheduler& scheduler) {
auto kex = factory.makeKeyExchange(group);
kex->generateKeyPair();
auto sharedSecret = kex->generateSharedSecret(clientShare->coalesce());
scheduler.deriveHandshakeSecret(sharedSecret->coalesce());
return kex->getKeyShare();
}
static Buf getHelloRetryRequest(
ProtocolVersion version,
CipherSuite cipher,
NamedGroup group,
Buf legacySessionId,
HandshakeContext& handshakeContext) {
Buf encodedHelloRetryRequest;
auto realVersion = getRealDraftVersion(version);
if (realVersion == ProtocolVersion::tls_1_3_20 ||
realVersion == ProtocolVersion::tls_1_3_21) {
throw std::runtime_error("pre-22 HRR");
}
HelloRetryRequest hrr;
hrr.legacy_version = ProtocolVersion::tls_1_2;
hrr.legacy_session_id_echo = std::move(legacySessionId);
hrr.cipher_suite = cipher;
ServerSupportedVersions versionExt;
versionExt.selected_version = version;
hrr.extensions.push_back(encodeExtension(std::move(versionExt)));
HelloRetryRequestKeyShare keyShare;
if (realVersion == ProtocolVersion::tls_1_3_20 ||
realVersion == ProtocolVersion::tls_1_3_21 ||
realVersion == ProtocolVersion::tls_1_3_22) {
keyShare.preDraft23 = true;
}
keyShare.selected_group = group;
hrr.extensions.push_back(encodeExtension(std::move(keyShare)));
encodedHelloRetryRequest = encodeHandshake(std::move(hrr));
handshakeContext.appendToTranscript(encodedHelloRetryRequest);
return encodedHelloRetryRequest;
}
static Buf getServerHello(
ProtocolVersion version,
Random random,
CipherSuite cipher,
bool psk,
Optional<NamedGroup> group,
Optional<Buf> serverShare,
Buf legacy_session_id,
HandshakeContext& handshakeContext) {
ServerHello serverHello;
auto realVersion = getRealDraftVersion(version);
if (realVersion == ProtocolVersion::tls_1_3_20 ||
realVersion == ProtocolVersion::tls_1_3_21) {
serverHello.legacy_version = version;
} else {
serverHello.legacy_version = ProtocolVersion::tls_1_2;
ServerSupportedVersions versionExt;
versionExt.selected_version = version;
serverHello.extensions.push_back(encodeExtension(std::move(versionExt)));
serverHello.legacy_session_id_echo = std::move(legacy_session_id);
}
serverHello.random = std::move(random);
serverHello.cipher_suite = cipher;
if (group) {
ServerKeyShare serverKeyShare;
serverKeyShare.server_share.group = *group;
serverKeyShare.server_share.key_exchange = std::move(*serverShare);
if (realVersion == ProtocolVersion::tls_1_3_20 ||
realVersion == ProtocolVersion::tls_1_3_21 ||
realVersion == ProtocolVersion::tls_1_3_22) {
serverKeyShare.preDraft23 = true;
}
serverHello.extensions.push_back(
encodeExtension(std::move(serverKeyShare)));
}
if (psk) {
ServerPresharedKey serverPsk;
serverPsk.selected_identity = kPskIndex;
serverHello.extensions.push_back(encodeExtension(std::move(serverPsk)));
}
auto encodedServerHello = encodeHandshake(std::move(serverHello));
handshakeContext.appendToTranscript(encodedServerHello);
return encodedServerHello;
}
static Optional<std::string> negotiateAlpn(
const ClientHello& chlo,
folly::Optional<std::string> zeroRttAlpn,
const FizzServerContext& context) {
auto ext = getExtension<ProtocolNameList>(chlo.extensions);
std::vector<std::string> clientProtocols;
if (ext) {
for (auto& protocol : ext->protocol_name_list) {
clientProtocols.push_back(protocol.name->moveToFbString().toStdString());
}
} else {
VLOG(6) << "Client did not send ALPN extension";
}
auto selected = context.negotiateAlpn(clientProtocols, zeroRttAlpn);
if (!selected) {
VLOG(6) << "ALPN mismatch";
} else {
VLOG(6) << "ALPN: " << *selected;
}
return selected;
}
static Optional<std::chrono::milliseconds> getClockSkew(
const Optional<ResumptionState>& psk,
Optional<uint32_t> obfuscatedAge) {
if (!psk || !obfuscatedAge) {
return folly::none;
}
auto age = std::chrono::milliseconds(
static_cast<uint32_t>(*obfuscatedAge - psk->ticketAgeAdd));
auto expected = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now() - psk->ticketIssueTime);
return std::chrono::milliseconds(age - expected);
}
static EarlyDataType negotiateEarlyDataType(
bool acceptEarlyData,
const ClientHello& chlo,
const Optional<ResumptionState>& psk,
CipherSuite cipher,
Optional<KeyExchangeType> keyExchangeType,
const Optional<CookieState>& cookieState,
Optional<std::string> alpn,
ReplayCacheResult replayCacheResult,
Optional<std::chrono::milliseconds> clockSkew,
ClockSkewTolerance clockSkewTolerance,
const AppTokenValidator* appTokenValidator) {
if (!getExtension<ClientEarlyData>(chlo.extensions)) {
return EarlyDataType::NotAttempted;
}
if (!acceptEarlyData) {
VLOG(5) << "Rejecting early data: disabled";
return EarlyDataType::Rejected;
}
if (!psk) {
VLOG(5) << "Rejected early data: psk rejected";
return EarlyDataType::Rejected;
}
if (psk->cipher != cipher) {
VLOG(5) << "Rejected early data: cipher mismatch";
return EarlyDataType::Rejected;
}
if (psk->alpn != alpn) {
VLOG(5) << "Rejecting early data: alpn mismatch";
return EarlyDataType::Rejected;
}
if (keyExchangeType &&
*keyExchangeType == KeyExchangeType::HelloRetryRequest) {
VLOG(5) << "Rejecting early data: HelloRetryRequest";
return EarlyDataType::Rejected;
}
if (cookieState) {
VLOG(5) << "Rejecting early data: Cookie";
return EarlyDataType::Rejected;
}
if (replayCacheResult != ReplayCacheResult::NotReplay) {
VLOG(5) << "Rejecting early data: replay";
return EarlyDataType::Rejected;
}
if (!clockSkew || *clockSkew < clockSkewTolerance.before ||
*clockSkew > clockSkewTolerance.after) {
VLOG(5) << "Rejecting early data: clock skew clockSkew="
<< (clockSkew ? folly::to<std::string>(clockSkew->count())
: "(none)")
<< " toleranceBefore=" << clockSkewTolerance.before.count()
<< " toleranceAfter=" << clockSkewTolerance.after.count();
return EarlyDataType::Rejected;
}
if (appTokenValidator && !appTokenValidator->validate(*psk)) {
VLOG(5) << "Rejecting early data: invalid app token";
return EarlyDataType::Rejected;
}
return EarlyDataType::Accepted;
}
static Buf getEncryptedExt(
HandshakeContext& handshakeContext,
const folly::Optional<std::string>& selectedAlpn,
EarlyDataType earlyData,
std::vector<Extension> otherExtensions) {
EncryptedExtensions encryptedExt;
if (selectedAlpn) {
ProtocolNameList alpn;
ProtocolName protocol;
protocol.name = folly::IOBuf::copyBuffer(*selectedAlpn);
alpn.protocol_name_list.push_back(std::move(protocol));
encryptedExt.extensions.push_back(encodeExtension(std::move(alpn)));
}
if (earlyData == EarlyDataType::Accepted) {
encryptedExt.extensions.push_back(encodeExtension(ServerEarlyData()));
}
for (auto& ext : otherExtensions) {
encryptedExt.extensions.push_back(std::move(ext));
}
auto encodedEncryptedExt =
encodeHandshake<EncryptedExtensions>(std::move(encryptedExt));
handshakeContext.appendToTranscript(encodedEncryptedExt);
return encodedEncryptedExt;
}
static std::pair<std::shared_ptr<SelfCert>, SignatureScheme> chooseCert(
const FizzServerContext& context,
const ClientHello& chlo) {
const auto& clientSigSchemes =
getExtension<SignatureAlgorithms>(chlo.extensions);
if (!clientSigSchemes) {
throw FizzException("no sig schemes", AlertDescription::missing_extension);
}
Optional<std::string> sni;
auto serverNameList = getExtension<ServerNameList>(chlo.extensions);
if (serverNameList && !serverNameList->server_name_list.empty()) {
sni = serverNameList->server_name_list.front()
.hostname->moveToFbString()
.toStdString();
}
auto certAndScheme =
context.getCert(sni, clientSigSchemes->supported_signature_algorithms);
if (!certAndScheme) {
throw FizzException(
"could not find suitable cert", AlertDescription::handshake_failure);
}
return *certAndScheme;
}
static std::tuple<Buf, folly::Optional<CertificateCompressionAlgorithm>>
getCertificate(
const std::shared_ptr<const SelfCert>& serverCert,
const FizzServerContext& context,
const ClientHello& chlo,
HandshakeContext& handshakeContext) {
// Check for compression support first, and if so, send compressed.
Buf encodedCertificate;
folly::Optional<CertificateCompressionAlgorithm> algo;
auto compAlgos =
getExtension<CertificateCompressionAlgorithms>(chlo.extensions);
if (compAlgos && !context.getSupportedCompressionAlgorithms().empty()) {
algo = negotiate(
context.getSupportedCompressionAlgorithms(), compAlgos->algorithms);
}
if (algo) {
encodedCertificate = encodeHandshake(serverCert->getCompressedCert(*algo));
} else {
encodedCertificate = encodeHandshake(serverCert->getCertMessage());
}
handshakeContext.appendToTranscript(encodedCertificate);
return std::make_tuple(std::move(encodedCertificate), std::move(algo));
}
static Buf getCertificateVerify(
SignatureScheme sigScheme,
Buf signature,
HandshakeContext& handshakeContext) {
CertificateVerify verify;
verify.algorithm = sigScheme;
verify.signature = std::move(signature);
auto encodedCertificateVerify = encodeHandshake(std::move(verify));
handshakeContext.appendToTranscript(encodedCertificateVerify);
return encodedCertificateVerify;
}
static Buf getCertificateRequest(
const std::vector<SignatureScheme>& acceptableSigSchemes,
const CertificateVerifier* const verifier,
HandshakeContext& handshakeContext) {
CertificateRequest request;
SignatureAlgorithms algos;
algos.supported_signature_algorithms = acceptableSigSchemes;
request.extensions.push_back(encodeExtension(std::move(algos)));
if (verifier) {
auto verifierExtensions = verifier->getCertificateRequestExtensions();
for (auto& ext : verifierExtensions) {
request.extensions.push_back(std::move(ext));
}
}
auto encodedCertificateRequest = encodeHandshake(std::move(request));
handshakeContext.appendToTranscript(encodedCertificateRequest);
return encodedCertificateRequest;
}
AsyncActions
EventHandler<ServerTypes, StateEnum::ExpectingClientHello, Event::ClientHello>::
handle(const State& state, Param param) {
auto chlo = std::move(boost::get<ClientHello>(param));
addHandshakeLogging(state, chlo);
if (state.readRecordLayer()->hasUnparsedHandshakeData()) {
throw FizzException(
"data after client hello", AlertDescription::unexpected_message);
}
auto version =
negotiateVersion(chlo, state.context()->getSupportedVersions());
if (state.version().hasValue() &&
(!version || *version != *state.version())) {
throw FizzException(
"version mismatch with previous negotiation",
AlertDescription::illegal_parameter);
}
if (!version) {
if (getExtension<ClientEarlyData>(chlo.extensions)) {
throw FizzException(
"supported version mismatch with early data",
AlertDescription::protocol_version);
}
if (state.context()->getVersionFallbackEnabled()) {
AttemptVersionFallback fallback;
// Re-encode to put the record layer header back on. This won't
// necessarily preserve it byte-for-byte, but it isn't authenticated so
// should be ok.
fallback.clientHello =
PlaintextWriteRecordLayer()
.writeInitialClientHello(std::move(*chlo.originalEncoding))
.data;
return actions(&Transition<StateEnum::Error>, std::move(fallback));
} else {
throw FizzException(
"supported version mismatch", AlertDescription::protocol_version);
}
}
state.writeRecordLayer()->setProtocolVersion(*version);
validateClientHello(chlo);
auto cipher = negotiateCipher(chlo, state.context()->getSupportedCiphers());
auto cookieState = getCookieState(
chlo, *version, cipher, state.context()->getCookieCipher());
auto resStateResult = getResumptionState(
chlo,
state.context()->getTicketCipher(),
state.context()->getSupportedPskModes());
auto replayCacheResultFuture = getReplayCacheResult(
chlo,
state.context()->getAcceptEarlyData(*version),
state.context()->getReplayCache());
auto results =
collectAll(resStateResult.futureResState, replayCacheResultFuture);
using FutureResultType = std::tuple<
folly::Try<std::pair<PskType, Optional<ResumptionState>>>,
folly::Try<ReplayCacheResult>>;
return results.via(state.executor())
.thenValue([&state,
chlo = std::move(chlo),
cookieState = std::move(cookieState),
version = *version,
cipher,
pskMode = resStateResult.pskMode,
obfuscatedAge = resStateResult.obfuscatedAge](
FutureResultType result) mutable {
auto& resumption = *std::get<0>(result);
auto pskType = resumption.first;
auto resState = std::move(resumption.second);
auto replayCacheResult = *std::get<1>(result);
if (resState) {
if (!validateResumptionState(*resState, *pskMode, version, cipher)) {
pskType = PskType::Rejected;
pskMode = folly::none;
resState = folly::none;
}
} else {
pskMode = folly::none;
}
Buf legacySessionId;
auto realVersion = getRealDraftVersion(version);
if (realVersion == ProtocolVersion::tls_1_3_20 ||
realVersion == ProtocolVersion::tls_1_3_21) {
legacySessionId = nullptr;
} else {
legacySessionId = chlo.legacy_session_id->clone();
}
std::unique_ptr<KeyScheduler> scheduler;
std::unique_ptr<HandshakeContext> handshakeContext;
std::tie(scheduler, handshakeContext) = setupSchedulerAndContext(
*state.context()->getFactory(),
cipher,
chlo,
resState,
cookieState,
pskType,
std::move(state.handshakeContext()),
version);
if (state.cipher().hasValue() && cipher != *state.cipher()) {
throw FizzException(
"cipher mismatch with previous negotiation",
AlertDescription::illegal_parameter);
}
auto alpn = negotiateAlpn(chlo, folly::none, *state.context());
auto clockSkew = getClockSkew(resState, obfuscatedAge);
auto earlyDataType = negotiateEarlyDataType(
state.context()->getAcceptEarlyData(version),
chlo,
resState,
cipher,
state.keyExchangeType(),
cookieState,
alpn,
replayCacheResult,
clockSkew,
state.context()->getClockSkewTolerance(),
state.appTokenValidator());
std::unique_ptr<EncryptedReadRecordLayer> earlyReadRecordLayer;
Buf earlyExporterMaster;
if (earlyDataType == EarlyDataType::Accepted) {
auto earlyContext = handshakeContext->getHandshakeContext();
earlyReadRecordLayer =
state.context()->getFactory()->makeEncryptedReadRecordLayer(
EncryptionLevel::EarlyData);
earlyReadRecordLayer->setProtocolVersion(version);
auto earlyReadSecret = scheduler->getSecret(
EarlySecrets::ClientEarlyTraffic, earlyContext->coalesce());
Protocol::setAead(
*earlyReadRecordLayer,
cipher,
folly::range(earlyReadSecret),
*state.context()->getFactory(),
*scheduler);
earlyExporterMaster =
folly::IOBuf::copyBuffer(folly::range(scheduler->getSecret(
EarlySecrets::EarlyExporter, earlyContext->coalesce())));
}
Optional<NamedGroup> group;
Optional<Buf> serverShare;
KeyExchangeType keyExchangeType;
if (!pskMode || *pskMode != PskKeyExchangeMode::psk_ke) {
Optional<Buf> clientShare;
std::tie(group, clientShare) = negotiateGroup(
version, chlo, state.context()->getSupportedGroups());
if (!clientShare) {
VLOG(8) << "Did not find key share for " << toString(*group);
if (state.group().hasValue() || cookieState) {
throw FizzException(
"key share not found for already negotiated group",
AlertDescription::illegal_parameter);
}
// If we were otherwise going to accept early data we now need to
// reject it. It's a little ugly to change our previous early data
// decision, but doing it this way allows us to move the key
// schedule forward as we do the key exchange.
if (earlyDataType == EarlyDataType::Accepted) {
earlyDataType = EarlyDataType::Rejected;
}
message_hash chloHash;
chloHash.hash = handshakeContext->getHandshakeContext();
handshakeContext =
state.context()->getFactory()->makeHandshakeContext(cipher);
handshakeContext->appendToTranscript(
encodeHandshake(std::move(chloHash)));
auto encodedHelloRetryRequest = getHelloRetryRequest(
version,
cipher,
*group,
legacySessionId ? legacySessionId->clone() : nullptr,
*handshakeContext);
WriteToSocket serverFlight;
serverFlight.contents.emplace_back(
state.writeRecordLayer()->writeHandshake(
std::move(encodedHelloRetryRequest)));
if (legacySessionId && !legacySessionId->empty()) {
TLSContent writeCCS;
writeCCS.encryptionLevel = EncryptionLevel::Plaintext;
writeCCS.contentType = ContentType::change_cipher_spec;
writeCCS.data = folly::IOBuf::wrapBuffer(FakeChangeCipherSpec);
serverFlight.contents.emplace_back(std::move(writeCCS));
}
// Create a new record layer in case we need to skip early data.
auto newReadRecordLayer =
state.context()->getFactory()->makePlaintextReadRecordLayer();
newReadRecordLayer->setSkipEncryptedRecords(
earlyDataType == EarlyDataType::Rejected);
return Future<Actions>(actions(
[handshakeContext = std::move(handshakeContext),
version,
cipher,
group,
earlyDataType,
replayCacheResult,
newReadRecordLayer =
std::move(newReadRecordLayer)](State& newState) mutable {
// Save some information about the current state to be
// validated when we get the second client hello. We don't
// validate that the second client hello matches the first as
// strictly as we could according to the spec however.
newState.handshakeContext() = std::move(handshakeContext);
newState.version() = version;
newState.cipher() = cipher;
newState.group() = group;
newState.keyExchangeType() =
KeyExchangeType::HelloRetryRequest;
newState.earlyDataType() = earlyDataType;
newState.replayCacheResult() = replayCacheResult;
newState.readRecordLayer() = std::move(newReadRecordLayer);
},
std::move(serverFlight),
&Transition<StateEnum::ExpectingClientHello>));
}
if (state.keyExchangeType().hasValue()) {
keyExchangeType = *state.keyExchangeType();
} else {
keyExchangeType = KeyExchangeType::OneRtt;
}
serverShare = doKex(
*state.context()->getFactory(), *group, *clientShare, *scheduler);
} else {
keyExchangeType = KeyExchangeType::None;
scheduler->deriveHandshakeSecret();
}
std::vector<Extension> additionalExtensions;
if (state.extensions()) {
additionalExtensions = state.extensions()->getExtensions(chlo);
}
if (state.group().hasValue() && (!group || *group != *state.group())) {
throw FizzException(
"group mismatch with previous negotiation",
AlertDescription::illegal_parameter);
}
// Cookies are not required to have already negotiated the group but if
// they did it must match (psk_ke is still allowed as we may not know if
// we are accepting the psk when sending the cookie).
if (cookieState && cookieState->group && group &&
*group != *cookieState->group) {
throw FizzException(
"group mismatch with cookie",
AlertDescription::illegal_parameter);
}
auto encodedServerHello = getServerHello(
version,
state.context()->getFactory()->makeRandom(),
cipher,
resState.hasValue(),
group,
std::move(serverShare),
legacySessionId ? legacySessionId->clone() : nullptr,
*handshakeContext);
// Derive handshake keys.
auto handshakeWriteRecordLayer =
state.context()->getFactory()->makeEncryptedWriteRecordLayer(
EncryptionLevel::Handshake);
handshakeWriteRecordLayer->setProtocolVersion(version);
auto handshakeWriteSecret = scheduler->getSecret(
HandshakeSecrets::ServerHandshakeTraffic,
handshakeContext->getHandshakeContext()->coalesce());
Protocol::setAead(
*handshakeWriteRecordLayer,
cipher,
folly::range(handshakeWriteSecret),
*state.context()->getFactory(),
*scheduler);
auto handshakeReadRecordLayer =
state.context()->getFactory()->makeEncryptedReadRecordLayer(
EncryptionLevel::Handshake);
handshakeReadRecordLayer->setProtocolVersion(version);
handshakeReadRecordLayer->setSkipFailedDecryption(
earlyDataType == EarlyDataType::Rejected);
auto handshakeReadSecret = scheduler->getSecret(
HandshakeSecrets::ClientHandshakeTraffic,
handshakeContext->getHandshakeContext()->coalesce());
Protocol::setAead(
*handshakeReadRecordLayer,
cipher,
folly::range(handshakeReadSecret),
*state.context()->getFactory(),
*scheduler);
auto clientHandshakeSecret =
folly::IOBuf::copyBuffer(folly::range(handshakeReadSecret));
auto encodedEncryptedExt = getEncryptedExt(
*handshakeContext,
alpn,
earlyDataType,
std::move(additionalExtensions));
/*
* Determine we are requesting client auth.
* If yes, add CertificateRequest to handshake write and transcript.
*/
bool requestClientAuth =
state.context()->getClientAuthMode() != ClientAuthMode::None &&
!resState;
Optional<Buf> encodedCertRequest;
if (requestClientAuth) {
encodedCertRequest = getCertificateRequest(
state.context()->getSupportedSigSchemes(),
state.context()->getClientCertVerifier().get(),
*handshakeContext);
}
/*
* Set the cert and signature scheme we are using.
* If sending new cert, add Certificate to handshake write and
* transcript.
*/
Optional<Buf> encodedCertificate;
Future<Optional<Buf>> signature = folly::none;
Optional<SignatureScheme> sigScheme;
Optional<std::shared_ptr<const Cert>> serverCert;
std::shared_ptr<const Cert> clientCert;
Optional<CertificateCompressionAlgorithm> certCompressionAlgo;
if (!resState) { // TODO or reauth
std::shared_ptr<const SelfCert> originalSelfCert;
std::tie(originalSelfCert, sigScheme) =
chooseCert(*state.context(), chlo);
std::tie(encodedCertificate, certCompressionAlgo) = getCertificate(
originalSelfCert, *state.context(), chlo, *handshakeContext);
auto toBeSigned = handshakeContext->getHandshakeContext();
auto asyncSelfCert =
dynamic_cast<const AsyncSelfCert*>(originalSelfCert.get());
if (asyncSelfCert) {
signature = asyncSelfCert->signFuture(
*sigScheme,
CertificateVerifyContext::Server,
toBeSigned->coalesce());
} else {
signature = originalSelfCert->sign(
*sigScheme,
CertificateVerifyContext::Server,
toBeSigned->coalesce());
}
serverCert = std::move(originalSelfCert);
} else {
serverCert = std::move(resState->serverCert);
clientCert = std::move(resState->clientCert);
}
return signature.via(state.executor())
.thenValue([&state,
scheduler = std::move(scheduler),
handshakeContext = std::move(handshakeContext),
cipher,
group,
encodedServerHello = std::move(encodedServerHello),
handshakeWriteRecordLayer =
std::move(handshakeWriteRecordLayer),
handshakeWriteSecret = std::move(handshakeWriteSecret),
handshakeReadRecordLayer =
std::move(handshakeReadRecordLayer),
earlyReadRecordLayer = std::move(earlyReadRecordLayer),
earlyExporterMaster = std::move(earlyExporterMaster),
clientHandshakeSecret =
std::move(clientHandshakeSecret),
encodedEncryptedExt = std::move(encodedEncryptedExt),
encodedCertificate = std::move(encodedCertificate),
encodedCertRequest = std::move(encodedCertRequest),
requestClientAuth,
pskType,
pskMode,
sigScheme,
version,
keyExchangeType,
earlyDataType,
replayCacheResult,
serverCert = std::move(serverCert),
clientCert = std::move(clientCert),
alpn = std::move(alpn),
clockSkew,
legacySessionId = std::move(legacySessionId),
serverCertCompAlgo =
certCompressionAlgo](Optional<Buf> sig) mutable {
Optional<Buf> encodedCertificateVerify;
if (sig) {
encodedCertificateVerify = getCertificateVerify(
*sigScheme, std::move(*sig), *handshakeContext);
}
auto encodedFinished = Protocol::getFinished(
folly::range(handshakeWriteSecret), *handshakeContext);
folly::IOBufQueue combined;
if (encodedCertificate) {
if (encodedCertRequest) {
combined.append(std::move(encodedEncryptedExt));
combined.append(std::move(*encodedCertRequest));
combined.append(std::move(*encodedCertificate));
combined.append(std::move(*encodedCertificateVerify));
combined.append(std::move(encodedFinished));
} else {
combined.append(std::move(encodedEncryptedExt));
combined.append(std::move(*encodedCertificate));
combined.append(std::move(*encodedCertificateVerify));
combined.append(std::move(encodedFinished));
}
} else {
combined.append(std::move(encodedEncryptedExt));
combined.append(std::move(encodedFinished));
}
// Some middleboxes appear to break if the first encrypted record
// is larger than ~1300 bytes (likely if it does not fit in the
// first packet).
auto serverEncrypted = handshakeWriteRecordLayer->writeHandshake(
combined.splitAtMost(1000));
if (!combined.empty()) {
auto splitRecord =
handshakeWriteRecordLayer->writeHandshake(combined.move());
// Split record must have the same encryption level as the main
// handshake.
DCHECK(
splitRecord.encryptionLevel ==
serverEncrypted.encryptionLevel);
serverEncrypted.data->prependChain(std::move(splitRecord.data));
}
WriteToSocket serverFlight;
serverFlight.contents.emplace_back(
state.writeRecordLayer()->writeHandshake(
std::move(encodedServerHello)));
if (legacySessionId && !legacySessionId->empty()) {
TLSContent ccsWrite;
ccsWrite.encryptionLevel = EncryptionLevel::Plaintext;
ccsWrite.contentType = ContentType::change_cipher_spec;
ccsWrite.data = folly::IOBuf::wrapBuffer(FakeChangeCipherSpec);
serverFlight.contents.emplace_back(std::move(ccsWrite));
}
serverFlight.contents.emplace_back(std::move(serverEncrypted));
scheduler->deriveMasterSecret();
auto clientFinishedContext =
handshakeContext->getHandshakeContext();
auto exporterMasterVector = scheduler->getSecret(
MasterSecrets::ExporterMaster,
clientFinishedContext->coalesce());
auto exporterMaster =
folly::IOBuf::copyBuffer(folly::range(exporterMasterVector));
scheduler->deriveAppTrafficSecrets(
clientFinishedContext->coalesce());
auto appTrafficWriteRecordLayer =
state.context()->getFactory()->makeEncryptedWriteRecordLayer(
EncryptionLevel::AppTraffic);
appTrafficWriteRecordLayer->setProtocolVersion(version);
auto writeSecret =
scheduler->getSecret(AppTrafficSecrets::ServerAppTraffic);
Protocol::setAead(
*appTrafficWriteRecordLayer,
cipher,
folly::range(writeSecret),
*state.context()->getFactory(),
*scheduler);
// If we have previously dealt with early data (before a
// HelloRetryRequest), don't overwrite the previous result.
auto earlyDataTypeSave = state.earlyDataType()
? *state.earlyDataType()
: earlyDataType;
// Save all the necessary state except for the read record layer,
// which is done separately as it varies if early data was
// accepted.
auto saveState = [appTrafficWriteRecordLayer =
std::move(appTrafficWriteRecordLayer),
handshakeContext = std::move(handshakeContext),
scheduler = std::move(scheduler),
exporterMaster = std::move(exporterMaster),
serverCert = std::move(serverCert),
clientCert = std::move(clientCert),
cipher,
group,
sigScheme,
clientHandshakeSecret =
std::move(clientHandshakeSecret),
pskType,
pskMode,
version,
keyExchangeType,
alpn = std::move(alpn),
earlyDataTypeSave,
replayCacheResult,
clockSkew,
serverCertCompAlgo](State& newState) mutable {
newState.writeRecordLayer() =
std::move(appTrafficWriteRecordLayer);
newState.handshakeContext() = std::move(handshakeContext);
newState.keyScheduler() = std::move(scheduler);
newState.exporterMasterSecret() = std::move(exporterMaster);
newState.serverCert() = std::move(*serverCert);
newState.clientCert() = std::move(clientCert);
newState.version() = version;
newState.cipher() = cipher;
newState.group() = group;
newState.sigScheme() = sigScheme;
newState.clientHandshakeSecret() =
std::move(clientHandshakeSecret);
newState.pskType() = pskType;
newState.pskMode() = pskMode;
newState.keyExchangeType() = keyExchangeType;
newState.earlyDataType() = earlyDataTypeSave;
newState.replayCacheResult() = replayCacheResult;
newState.alpn() = std::move(alpn);
newState.clientClockSkew() = clockSkew;
newState.serverCertCompAlgo() = serverCertCompAlgo;
};
if (earlyDataType == EarlyDataType::Accepted) {
return actions(
[handshakeReadRecordLayer =
std::move(handshakeReadRecordLayer),
earlyReadRecordLayer = std::move(earlyReadRecordLayer),
earlyExporterMaster = std::move(earlyExporterMaster)](
State& newState) mutable {
newState.readRecordLayer() =
std::move(earlyReadRecordLayer);
newState.handshakeReadRecordLayer() =
std::move(handshakeReadRecordLayer);
newState.earlyExporterMasterSecret() =
std::move(earlyExporterMaster);
},
std::move(saveState),
std::move(serverFlight),
&Transition<StateEnum::AcceptingEarlyData>,
ReportEarlyHandshakeSuccess());
} else {
auto transition = requestClientAuth
? Transition<StateEnum::ExpectingCertificate>
: Transition<StateEnum::ExpectingFinished>;
return actions(
[handshakeReadRecordLayer = std::move(
handshakeReadRecordLayer)](State& newState) mutable {
newState.readRecordLayer() =
std::move(handshakeReadRecordLayer);
},
std::move(saveState),
std::move(serverFlight),
transition);
}
});
});
}
AsyncActions
EventHandler<ServerTypes, StateEnum::AcceptingEarlyData, Event::AppData>::
handle(const State&, Param param) {
auto& appData = boost::get<AppData>(param);
return actions(DeliverAppData{std::move(appData.data)});
}
AsyncActions
EventHandler<ServerTypes, StateEnum::AcceptingEarlyData, Event::AppWrite>::
handle(const State& state, Param param) {
auto& appWrite = boost::get<AppWrite>(param);
WriteToSocket write;
write.callback = appWrite.callback;
write.contents.emplace_back(
state.writeRecordLayer()->writeAppData(std::move(appWrite.data)));
write.flags = appWrite.flags;
return actions(std::move(write));
}
AsyncActions EventHandler<
ServerTypes,
StateEnum::AcceptingEarlyData,
Event::EndOfEarlyData>::handle(const State& state, Param param) {
auto& eoed = boost::get<EndOfEarlyData>(param);
if (state.readRecordLayer()->hasUnparsedHandshakeData()) {
throw FizzException(
"data after eoed", AlertDescription::unexpected_message);
}
state.handshakeContext()->appendToTranscript(*eoed.originalEncoding);
auto readRecordLayer = std::move(state.handshakeReadRecordLayer());
return actions(
[readRecordLayer = std::move(readRecordLayer)](State& newState) mutable {
newState.readRecordLayer() = std::move(readRecordLayer);
},
&Transition<StateEnum::ExpectingFinished>);
}
AsyncActions
EventHandler<ServerTypes, StateEnum::ExpectingFinished, Event::AppWrite>::
handle(const State& state, Param param) {
auto& appWrite = boost::get<AppWrite>(param);
WriteToSocket write;
write.callback = appWrite.callback;
write.contents.emplace_back(
state.writeRecordLayer()->writeAppData(std::move(appWrite.data)));
write.flags = appWrite.flags;
return actions(std::move(write));
}
static WriteToSocket writeNewSessionTicket(
const FizzServerContext& context,
const WriteRecordLayer& recordLayer,
std::chrono::seconds ticketLifetime,
uint32_t ticketAgeAdd,
Buf nonce,
Buf ticket,
ProtocolVersion version) {
NewSessionTicket nst;
nst.ticket_lifetime = ticketLifetime.count();
nst.ticket_age_add = ticketAgeAdd;
nst.ticket_nonce = std::move(nonce);
nst.ticket = std::move(ticket);
if (context.getAcceptEarlyData(version)) {
TicketEarlyData early;
early.max_early_data_size = context.getMaxEarlyDataSize();
nst.extensions.push_back(encodeExtension(std::move(early)));
}
auto encodedNst = encodeHandshake(std::move(nst));
WriteToSocket nstWrite;
nstWrite.contents.emplace_back(
recordLayer.writeHandshake(std::move(encodedNst)));
return nstWrite;
}
static Future<Optional<WriteToSocket>> generateTicket(
const State& state,
const std::vector<uint8_t>& resumptionMasterSecret,
Buf appToken = nullptr) {
auto ticketCipher = state.context()->getTicketCipher();
if (!ticketCipher || *state.pskType() == PskType::NotSupported) {
return folly::none;
}
Buf ticketNonce;
Buf resumptionSecret;
auto realDraftVersion = getRealDraftVersion(*state.version());
if (realDraftVersion == ProtocolVersion::tls_1_3_20) {
ticketNonce = nullptr;
resumptionSecret =
folly::IOBuf::copyBuffer(folly::range(resumptionMasterSecret));
} else {
ticketNonce = folly::IOBuf::create(0);
resumptionSecret = state.keyScheduler()->getResumptionSecret(
folly::range(resumptionMasterSecret), ticketNonce->coalesce());
}
ResumptionState resState;
resState.version = *state.version();
resState.cipher = *state.cipher();
resState.resumptionSecret = std::move(resumptionSecret);
resState.serverCert = state.serverCert();
resState.clientCert = state.clientCert();
resState.alpn = state.alpn();
resState.ticketAgeAdd = state.context()->getFactory()->makeTicketAgeAdd();
resState.ticketIssueTime = std::chrono::system_clock::now();
resState.appToken = std::move(appToken);
auto ticketFuture = ticketCipher->encrypt(std::move(resState));
return ticketFuture.via(state.executor())
.thenValue(
[&state,
ticketAgeAdd = resState.ticketAgeAdd,
ticketNonce = std::move(ticketNonce)](
Optional<std::pair<Buf, std::chrono::seconds>> ticket) mutable
-> Optional<WriteToSocket> {
if (!ticket) {
return folly::none;
}
return writeNewSessionTicket(
*state.context(),
*state.writeRecordLayer(),
ticket->second,
ticketAgeAdd,
std::move(ticketNonce),
std::move(ticket->first),
*state.version());
});
}
AsyncActions
EventHandler<ServerTypes, StateEnum::ExpectingCertificate, Event::Certificate>::
handle(const State& state, Param param) {
auto certMsg = std::move(boost::get<CertificateMsg>(param));
state.handshakeContext()->appendToTranscript(*certMsg.originalEncoding);
if (!certMsg.certificate_request_context->empty()) {
throw FizzException(
"certificate request context must be empty",
AlertDescription::illegal_parameter);
}
std::vector<std::shared_ptr<const PeerCert>> clientCerts;
for (auto& certEntry : certMsg.certificate_list) {
// We don't request any extensions, so this ought to be empty
if (!certEntry.extensions.empty()) {
throw FizzException(
"certificate extensions must be empty",
AlertDescription::illegal_parameter);
}
clientCerts.emplace_back(state.context()->getFactory()->makePeerCert(
std::move(certEntry.cert_data)));
}
if (clientCerts.empty()) {
if (state.context()->getClientAuthMode() == ClientAuthMode::Optional) {
VLOG(6) << "Client authentication not sent";
return actions(
[](State& newState) { newState.unverifiedCertChain() = folly::none; },
&Transition<StateEnum::ExpectingFinished>);
} else {
throw FizzException(
"certificate requested but none received",
AlertDescription::certificate_required);
}
} else {
return actions(
[certs = std::move(clientCerts)](State& newState) mutable {
newState.unverifiedCertChain() = std::move(certs);
},
&Transition<StateEnum::ExpectingCertificateVerify>);
}
}
AsyncActions EventHandler<
ServerTypes,
StateEnum::ExpectingCertificateVerify,
Event::CertificateVerify>::handle(const State& state, Param param) {
auto certVerify = std::move(boost::get<CertificateVerify>(param));
if (std::find(
state.context()->getSupportedSigSchemes().begin(),
state.context()->getSupportedSigSchemes().end(),
certVerify.algorithm) ==
state.context()->getSupportedSigSchemes().end()) {
throw FizzException(
folly::to<std::string>(
"client chose unsupported sig scheme: ",
toString(certVerify.algorithm)),
AlertDescription::handshake_failure);
}
const auto& certs = *state.unverifiedCertChain();
auto leafCert = certs.front();
leafCert->verify(
certVerify.algorithm,
CertificateVerifyContext::Client,
state.handshakeContext()->getHandshakeContext()->coalesce(),
certVerify.signature->coalesce());
try {
const auto& verifier = state.context()->getClientCertVerifier();
if (verifier) {
verifier->verify(certs);
}
} catch (const FizzException&) {
throw;
} catch (const std::exception& e) {
throw FizzVerificationException(
folly::to<std::string>("client certificate failure: ", e.what()),
AlertDescription::bad_certificate);
}
state.handshakeContext()->appendToTranscript(*certVerify.originalEncoding);
return actions(
[cert = std::move(leafCert)](State& newState) {
newState.unverifiedCertChain() = folly::none;
newState.clientCert() = std::move(cert);
},
&Transition<StateEnum::ExpectingFinished>);
}
AsyncActions
EventHandler<ServerTypes, StateEnum::ExpectingFinished, Event::Finished>::
handle(const State& state, Param param) {
auto& finished = boost::get<Finished>(param);
auto expectedFinished = state.handshakeContext()->getFinishedData(
state.clientHandshakeSecret()->coalesce());
if (!CryptoUtils::equal(
expectedFinished->coalesce(), finished.verify_data->coalesce())) {
throw FizzException("client finished verify failure", folly::none);
}
if (state.readRecordLayer()->hasUnparsedHandshakeData()) {
throw FizzException("data after finished", folly::none);
}
auto readRecordLayer =
state.context()->getFactory()->makeEncryptedReadRecordLayer(
EncryptionLevel::AppTraffic);
readRecordLayer->setProtocolVersion(*state.version());
auto readSecret =
state.keyScheduler()->getSecret(AppTrafficSecrets::ClientAppTraffic);
Protocol::setAead(
*readRecordLayer,
*state.cipher(),
folly::range(readSecret),
*state.context()->getFactory(),
*state.keyScheduler());
state.handshakeContext()->appendToTranscript(*finished.originalEncoding);
auto resumptionMasterSecret = state.keyScheduler()->getSecret(
MasterSecrets::ResumptionMaster,
state.handshakeContext()->getHandshakeContext()->coalesce());
state.keyScheduler()->clearMasterSecret();
auto saveState = [readRecordLayer = std::move(readRecordLayer),
resumptionMasterSecret](State& newState) mutable {
newState.readRecordLayer() = std::move(readRecordLayer);
newState.resumptionMasterSecret() = std::move(resumptionMasterSecret);
};
if (!state.context()->getSendNewSessionTicket()) {
return actions(
std::move(saveState),
&Transition<StateEnum::AcceptingData>,
ReportHandshakeSuccess());
} else {
auto ticketFuture = generateTicket(state, resumptionMasterSecret);
return ticketFuture.via(state.executor())
.thenValue([saveState = std::move(saveState)](
Optional<WriteToSocket> nstWrite) mutable {
if (!nstWrite) {
return actions(
std::move(saveState),
&Transition<StateEnum::AcceptingData>,
ReportHandshakeSuccess());
}
return actions(
std::move(saveState),
&Transition<StateEnum::AcceptingData>,
std::move(*nstWrite),
ReportHandshakeSuccess());
});
}
}
AsyncActions EventHandler<
ServerTypes,
StateEnum::AcceptingData,
Event::WriteNewSessionTicket>::handle(const State& state, Param param) {
auto& writeNewSessionTicket = boost::get<WriteNewSessionTicket>(param);
auto ticketFuture = generateTicket(
state,
state.resumptionMasterSecret(),
std::move(writeNewSessionTicket.appToken));
return ticketFuture.via(state.executor())
.thenValue([](Optional<WriteToSocket> nstWrite) {
if (!nstWrite) {
return actions();
}
return actions(std::move(*nstWrite));
});
}
AsyncActions
EventHandler<ServerTypes, StateEnum::AcceptingData, Event::AppData>::handle(
const State& /*state*/,
Param param) {
auto& appData = boost::get<AppData>(param);
return actions(DeliverAppData{std::move(appData.data)});
}
AsyncActions
EventHandler<ServerTypes, StateEnum::AcceptingData, Event::AppWrite>::handle(
const State& state,
Param param) {
auto& appWrite = boost::get<AppWrite>(param);
WriteToSocket write;
write.callback = appWrite.callback;
write.contents.emplace_back(
state.writeRecordLayer()->writeAppData(std::move(appWrite.data)));
write.flags = appWrite.flags;
return actions(std::move(write));
}
AsyncActions
EventHandler<ServerTypes, StateEnum::AcceptingData, Event::KeyUpdate>::handle(
const State& state,
Param param) {
auto& keyUpdate = boost::get<KeyUpdate>(param);
if (state.readRecordLayer()->hasUnparsedHandshakeData()) {
throw FizzException("data after key_update", folly::none);
}
state.keyScheduler()->clientKeyUpdate();
auto readRecordLayer =
state.context()->getFactory()->makeEncryptedReadRecordLayer(
EncryptionLevel::AppTraffic);
readRecordLayer->setProtocolVersion(*state.version());
auto readSecret =
state.keyScheduler()->getSecret(AppTrafficSecrets::ClientAppTraffic);
Protocol::setAead(
*readRecordLayer,
*state.cipher(),
folly::range(readSecret),
*state.context()->getFactory(),
*state.keyScheduler());
if (keyUpdate.request_update == KeyUpdateRequest::update_not_requested) {
return actions(
[rRecordLayer = std::move(readRecordLayer)](State& newState) mutable {
newState.readRecordLayer() = std::move(rRecordLayer);
});
}
auto encodedKeyUpdated =
Protocol::getKeyUpdated(KeyUpdateRequest::update_not_requested);
WriteToSocket write;
write.contents.emplace_back(
state.writeRecordLayer()->writeHandshake(std::move(encodedKeyUpdated)));
state.keyScheduler()->serverKeyUpdate();
auto writeRecordLayer =
state.context()->getFactory()->makeEncryptedWriteRecordLayer(
EncryptionLevel::AppTraffic);
writeRecordLayer->setProtocolVersion(*state.version());
auto writeSecret =
state.keyScheduler()->getSecret(AppTrafficSecrets::ServerAppTraffic);
Protocol::setAead(
*writeRecordLayer,
*state.cipher(),
folly::range(writeSecret),
*state.context()->getFactory(),
*state.keyScheduler());
return actions(
[rRecordLayer = std::move(readRecordLayer),
wRecordLayer = std::move(writeRecordLayer)](State& newState) mutable {
newState.readRecordLayer() = std::move(rRecordLayer);
newState.writeRecordLayer() = std::move(wRecordLayer);
},
std::move(write));
}
} // namespace sm
} // namespace fizz
| [
"facebook-github-bot@users.noreply.github.com"
] | facebook-github-bot@users.noreply.github.com |
1aed340026817b97f251d1eb6b92ee6e147faa29 | 74c8da5b29163992a08a376c7819785998afb588 | /NetAnimal/Game/Coding/Coding/coding.h | 8d3d8e430f5b56f2c856f33cbf59a8af3477c110 | [] | no_license | dbabox/aomi | dbfb46c1c9417a8078ec9a516cc9c90fe3773b78 | 4cffc8e59368e82aed997fe0f4dcbd7df626d1d0 | refs/heads/master | 2021-01-13T14:05:10.813348 | 2011-06-07T09:36:41 | 2011-06-07T09:36:41 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 918 | h | #ifndef CODING_H
#define CODING_H
#include <QtGui/QMainWindow>
#include "ui_coding.h"
#include <orz/Framework_Component/FrameworkComponentAllInclude.h>
#include <orz/Framework_Base/FrameworkBase.h>
#include <orz/Toolkit_Base/DynLibManager.h>
class Coding : public QMainWindow
{
Q_OBJECT
public:
Coding(QWidget *parent = 0, Qt::WFlags flags = 0);
~Coding();
private:
Ui::CodingClass ui;
boost::shared_ptr<Orz::SystemByFunctor<> > _system;
std::string _text1;
std::string _text2;
std::string _text3;
std::string _text4;
std::string _text;
Orz::ComponentPtr _coding;
Orz::ComponentPtr _lock;
public slots:
void dirui();
void dirui2();
void textChange1(const QString & text);
void textChange2(const QString & text);
void textChange3(const QString & text);
void textChange4(const QString & text);
void textChange(const QString & text);
};
#endif // CODING_H
| [
"ogre3d@yeah.net"
] | ogre3d@yeah.net |
ef67da1f42945a747d459fe31a82ca999135596b | 3282ccae547452b96c4409e6b5a447f34b8fdf64 | /SimModel_Python_API/simmodel_swig/SimModel_Dll_lib/framework/SimWindowType_Window.cxx | 822c0b861911d74b17a9acdac7c8c820acd332c6 | [
"MIT"
] | permissive | EnEff-BIM/EnEffBIM-Framework | c8bde8178bb9ed7d5e3e5cdf6d469a009bcb52de | 6328d39b498dc4065a60b5cc9370b8c2a9a1cddf | refs/heads/master | 2021-01-18T00:16:06.546875 | 2017-04-18T08:03:40 | 2017-04-18T08:03:40 | 28,960,534 | 3 | 0 | null | 2017-04-18T08:03:40 | 2015-01-08T10:19:18 | C++ | UTF-8 | C++ | false | false | 3,600 | cxx | // Copyright (c) 2005-2014 Code Synthesis Tools CC
//
// This program was generated by CodeSynthesis XSD, an XML Schema to
// C++ data binding compiler.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
//
// In addition, as a special exception, Code Synthesis Tools CC gives
// permission to link this program with the Xerces-C++ library (or with
// modified versions of Xerces-C++ that use the same license as Xerces-C++),
// and distribute linked combinations including the two. You must obey
// the GNU General Public License version 2 in all respects for all of
// the code used other than Xerces-C++. If you modify this copy of the
// program, you may extend this exception to your version of the program,
// but you are not obligated to do so. If you do not wish to do so, delete
// this exception statement from your version.
//
// Furthermore, Code Synthesis Tools CC makes a special exception for
// the Free/Libre and Open Source Software (FLOSS) which is described
// in the accompanying FLOSSE file.
//
// Begin prologue.
//
//
// End prologue.
#include <xsd/cxx/pre.hxx>
#include "SimWindowType_Window.hxx"
namespace schema
{
namespace simxml
{
namespace BuildingModel
{
// SimWindowType_Window
//
}
}
}
#include <xsd/cxx/xml/dom/parsing-source.hxx>
#include <xsd/cxx/tree/type-factory-map.hxx>
namespace _xsd
{
static
const ::xsd::cxx::tree::type_factory_plate< 0, char >
type_factory_plate_init;
}
namespace schema
{
namespace simxml
{
namespace BuildingModel
{
// SimWindowType_Window
//
SimWindowType_Window::
SimWindowType_Window ()
: ::schema::simxml::BuildingModel::SimWindowType ()
{
}
SimWindowType_Window::
SimWindowType_Window (const RefId_type& RefId)
: ::schema::simxml::BuildingModel::SimWindowType (RefId)
{
}
SimWindowType_Window::
SimWindowType_Window (const SimWindowType_Window& x,
::xml_schema::flags f,
::xml_schema::container* c)
: ::schema::simxml::BuildingModel::SimWindowType (x, f, c)
{
}
SimWindowType_Window::
SimWindowType_Window (const ::xercesc::DOMElement& e,
::xml_schema::flags f,
::xml_schema::container* c)
: ::schema::simxml::BuildingModel::SimWindowType (e, f, c)
{
}
SimWindowType_Window* SimWindowType_Window::
_clone (::xml_schema::flags f,
::xml_schema::container* c) const
{
return new class SimWindowType_Window (*this, f, c);
}
SimWindowType_Window::
~SimWindowType_Window ()
{
}
}
}
}
#include <istream>
#include <xsd/cxx/xml/sax/std-input-source.hxx>
#include <xsd/cxx/tree/error-handler.hxx>
namespace schema
{
namespace simxml
{
namespace BuildingModel
{
}
}
}
#include <xsd/cxx/post.hxx>
// Begin epilogue.
//
//
// End epilogue.
| [
"cao@e3d.rwth-aachen.de"
] | cao@e3d.rwth-aachen.de |
70d72fa35691d1629a8a1d725bbdcbf65aa6cbdd | 76c2464e21661c56f62da197ab9bcb88d309a005 | /CppCollection/IniTurboV3.10.h | a8cb7905b8749f2aa9aa1fbb290e4db5bc9e018b | [
"MIT"
] | permissive | huoyongkai/Wireless360 | fbb03c4a9932ae432d50fe5658a5eb81e8134e76 | 20b458809b16aa05316cbbe98d2aebc10b4ba19f | refs/heads/master | 2022-11-11T20:23:11.077025 | 2020-06-25T03:59:54 | 2020-06-25T03:59:54 | 274,699,320 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,830 | h |
/**
* @file
* @brief Turbo codec
* @version 3.10
* @author Yongkai HUO, yh3g09 (forevervhuo@gmail.com, yh3g09@ecs.soton.ac.uk)
* @date Aug 8, 2010-July 14, 2011
* @copyright None.
*/
#ifndef INITURBO_H
#define INITURBO_H
//#define $IniParser
//#define $Puncturer
#include "Headers.h"
#include IniParser_H
#include Puncturer_H
/**
* @brief Ini file inited turbo codec (heriting from Turbo_Codec of it++)
*/
class IniTurbo:protected Turbo_Codec
{
IniParser m_parser;
//! puncturer
Puncturer m_puncturer;
//! true to invoke puncturing
bool m_isPuncOn;
//! interleaver inited or not
bool m_interleaverInited;
//! clean the settings
void Clear();
//! constraint length
int m_constraintlength;
//! length of tail bits
int m_taillen;
//! generators
ivec m_decgenerators[2];
public:
IniTurbo();
/**
* @brief init turbo codec from ini file
* @param _iniFile name of ini file
* @param _section section to use in the ini file
* @param _prefix the prefix for all the keys in the effective section
*/
IniTurbo(const string& _iniFile,const string& _section,const string& _prefix="");
/**
* @brief init turbo codec from ini file
* @param _iniFile name of ini file
* @param _section section to use in the ini file
* @param _prefix the prefix for all the keys in the effective section
*/
void Set_Parameters(const string& _iniFile,const string& _section,const string& _prefix="");
/**
* @brief encode a bit sequence
* @param input input bits
* @param output coded bits
*/
void Encode(const bvec &input, bvec &output);
/**
* @brief decode a received soft sequence
* @param received_signal received soft sequence
* @param decoded_bits decoded bits
* @param _iteration iteration number (if negetive we will use the last setting)
*/
void Decode(const vec &received_signal, bvec &decoded_bits,int _iteration=-1);
/**
* @brief set parameter for awgn channel
* @details this is only used for raw signals from channel. For LLR values,
* plz call Set_scaling_factor(1.0);- which is also defauled as 1.0.
* @param in_Ec energy of bits
* @param in_N0 channel noise
*/
void Set_awgn_channel_parameters(double in_Ec, double in_N0);
/**
* @brief set scaling factor. should set as 1.0 for LLR signals.
*/
void Set_scaling_factor(double in_Lc);
//! get code rate of the turbo code. Puncturer considered.
inline double Get_CodeRate();
};
inline double IniTurbo::Get_CodeRate()
{
if(m_isPuncOn)
{
return m_puncturer.Get_codeRate_punctured();
}
return 1.0/(m_decgenerators[0].length()-1+m_decgenerators[1].length()-1+1);
}
#endif // INITURBO_H
| [
"ykhuo@hotmail.com"
] | ykhuo@hotmail.com |
f2d30e555d2f98c3bd407a70b973a23a5b2ec6ce | a7764174fb0351ea666faa9f3b5dfe304390a011 | /drv/ShapeSchema/ShapeSchema_PColPGeom2d_HArray1OfBezierCurve.cxx | 578011a4dedce09a025091239c71778cecf3aa75 | [] | no_license | uel-dataexchange/Opencascade_uel | f7123943e9d8124f4fa67579e3cd3f85cfe52d91 | 06ec93d238d3e3ea2881ff44ba8c21cf870435cd | refs/heads/master | 2022-11-16T07:40:30.837854 | 2020-07-08T01:56:37 | 2020-07-08T01:56:37 | 276,290,778 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,683 | cxx | #ifndef _ShapeSchema_PColPGeom2d_HArray1OfBezierCurve_HeaderFile
#include <ShapeSchema_PColPGeom2d_HArray1OfBezierCurve.hxx>
#endif
#ifndef _PColPGeom2d_HArray1OfBezierCurve_HeaderFile
#include <PColPGeom2d_HArray1OfBezierCurve.hxx>
#endif
#include <ShapeSchema_PColPGeom2d_HArray1OfBezierCurve.ixx>
#ifndef _Storage_Schema_HeaderFile
#include <Storage_Schema.hxx>
#endif
#ifndef _Storage_stCONSTclCOM_HeaderFile
#include <Storage_stCONSTclCOM.hxx>
#endif
IMPLEMENT_STANDARD_HANDLE(ShapeSchema_PColPGeom2d_HArray1OfBezierCurve,Storage_CallBack)
IMPLEMENT_STANDARD_RTTIEXT(ShapeSchema_PColPGeom2d_HArray1OfBezierCurve,Storage_CallBack)
Handle(Standard_Persistent) ShapeSchema_PColPGeom2d_HArray1OfBezierCurve::New() const
{
return new PColPGeom2d_HArray1OfBezierCurve(Storage_stCONSTclCOM());
}
void ShapeSchema_PColPGeom2d_HArray1OfBezierCurve::SAdd(const Handle(PColPGeom2d_HArray1OfBezierCurve)& p, const Handle(Storage_Schema)& theSchema)
{
if (!p.IsNull()) {
if (theSchema->AddPersistent(p,"PColPGeom2d_HArray1OfBezierCurve")) {
ShapeSchema_PColPGeom2d_FieldOfHArray1OfBezierCurve::SAdd(p->_CSFDB_GetPColPGeom2d_HArray1OfBezierCurveData(),theSchema);
}
}
}
void ShapeSchema_PColPGeom2d_HArray1OfBezierCurve::Add(const Handle(Standard_Persistent)& p, const Handle(Storage_Schema)& theSchema) const
{
ShapeSchema_PColPGeom2d_HArray1OfBezierCurve::SAdd((Handle(PColPGeom2d_HArray1OfBezierCurve)&)p,theSchema);
}
void ShapeSchema_PColPGeom2d_HArray1OfBezierCurve::SWrite(const Handle(Standard_Persistent)& p, Storage_BaseDriver& f, const Handle(Storage_Schema)& theSchema)
{
if (!p.IsNull()) {
Handle(PColPGeom2d_HArray1OfBezierCurve) &pp = (Handle(PColPGeom2d_HArray1OfBezierCurve)&)p;
theSchema->WritePersistentObjectHeader(p,f);
f.BeginWritePersistentObjectData();
f.PutInteger(pp->_CSFDB_GetPColPGeom2d_HArray1OfBezierCurveLowerBound());
f.PutInteger(pp->_CSFDB_GetPColPGeom2d_HArray1OfBezierCurveUpperBound());
ShapeSchema_PColPGeom2d_FieldOfHArray1OfBezierCurve::SWrite(pp->_CSFDB_GetPColPGeom2d_HArray1OfBezierCurveData(),f,theSchema);
f.EndWritePersistentObjectData();
}
}
void ShapeSchema_PColPGeom2d_HArray1OfBezierCurve::Write(const Handle(Standard_Persistent)& p, Storage_BaseDriver& f, const Handle(Storage_Schema)& theSchema) const
{
ShapeSchema_PColPGeom2d_HArray1OfBezierCurve::SWrite(p,f,theSchema);
}
void ShapeSchema_PColPGeom2d_HArray1OfBezierCurve::SRead(const Handle(Standard_Persistent)& p, Storage_BaseDriver& f, const Handle(Storage_Schema)& theSchema)
{
if (!p.IsNull()) {
Handle(PColPGeom2d_HArray1OfBezierCurve) &pp = (Handle(PColPGeom2d_HArray1OfBezierCurve)&)p;
theSchema->ReadPersistentObjectHeader(f);
f.BeginReadPersistentObjectData();
Standard_Integer PColPGeom2d_HArray1OfBezierCurveLowerBound;
f.GetInteger(PColPGeom2d_HArray1OfBezierCurveLowerBound);
pp->_CSFDB_SetPColPGeom2d_HArray1OfBezierCurveLowerBound(PColPGeom2d_HArray1OfBezierCurveLowerBound);
Standard_Integer PColPGeom2d_HArray1OfBezierCurveUpperBound;
f.GetInteger(PColPGeom2d_HArray1OfBezierCurveUpperBound);
pp->_CSFDB_SetPColPGeom2d_HArray1OfBezierCurveUpperBound(PColPGeom2d_HArray1OfBezierCurveUpperBound);
ShapeSchema_PColPGeom2d_FieldOfHArray1OfBezierCurve::SRead((PColPGeom2d_FieldOfHArray1OfBezierCurve&)pp->_CSFDB_GetPColPGeom2d_HArray1OfBezierCurveData(),f,theSchema);
f.EndReadPersistentObjectData();
}
}
void ShapeSchema_PColPGeom2d_HArray1OfBezierCurve::Read(const Handle(Standard_Persistent)& p, Storage_BaseDriver& f, const Handle(Storage_Schema)& theSchema) const
{
ShapeSchema_PColPGeom2d_HArray1OfBezierCurve::SRead(p,f,theSchema);
}
| [
"shoka.sho2@excel.co.jp"
] | shoka.sho2@excel.co.jp |
a719e713d56068179c668d6c6acdd87a6287b4fb | 74125d889be8312867038c7ed87db3de8680e14a | /Framework/Framework/source/src/MarchingCube.cpp | 258239556459cb1a607af72ca4492a1672a938c0 | [] | no_license | leezhongshan/3D-Framework | 7c0e29eef618879d8c8f27699ace458777fd134e | a81e9041d893b87787ec5e39d51a314968c24103 | refs/heads/master | 2021-01-18T10:12:27.464207 | 2014-12-23T10:11:51 | 2014-12-23T10:11:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 22,140 | cpp | #include "MarchingCube.h"
MarchingCubes::MarchingCubes()
{
}
MarchingCubes::~MarchingCubes()
{
}
// the marching cubes algorithm
unsigned int MarchingCubes::marchCube(const glm::ivec3& a_pCubeCorners, const glm::vec3& a_pCubeSize,
float*** a_fVolume, float a_fVolumeThreshold, glm::vec3* a_pVerts)
{
unsigned int vertexCount = 0;
// store a local copy of the cube's corner volumes
float cornerVolumes[8];
for ( int cornerIndex = 0; cornerIndex < 8; ++cornerIndex)
{
glm::ivec3 position = a_pCubeCorners + CUBE_CORNERS[ cornerIndex ];
cornerVolumes[ cornerIndex ] = a_fVolume[ position.x ][ position.y ][ position.z ];
}
// find which corners are inside/outside the volume
int flagIndex = 0;
for ( int cornerIndex = 0; cornerIndex < 8; ++cornerIndex)
{
if (cornerVolumes[ cornerIndex ] <= a_fVolumeThreshold)
flagIndex |= 1<<cornerIndex;
}
// a vertex position for each edge
glm::vec3 edgePosition[12];
// find the intersection point between an edge
// also find the normal for the new vertex
float offset;
for ( int edgeIndex = 0 ; edgeIndex < 12 ; ++edgeIndex )
{
// test for intersection along an edge
if (CUBE_EDGE_FLAGS[ flagIndex ] & (1<<edgeIndex))
{
// calculate intersection point along an edge
float delta = cornerVolumes[ EDGE_INDICES[ edgeIndex ][1] ] -
cornerVolumes[ EDGE_INDICES[ edgeIndex ][0] ];
if (delta == 0.0)
offset = 0.5;
offset = (a_fVolumeThreshold - cornerVolumes[ EDGE_INDICES[ edgeIndex ][0] ]) / delta;
// calculate position of vertex along edge
edgePosition[ edgeIndex ] = glm::vec3(a_pCubeCorners) * a_pCubeSize +
(glm::vec3(CUBE_CORNERS[ EDGE_INDICES[ edgeIndex ][0] ]) +
offset * EDGE_DIRECTIONS[ edgeIndex ]) * a_pCubeSize;
}
}
// store the position and normals for the triangles that were found.
// there can be up to five per cube
for ( int triangleIndex = 0 ; triangleIndex < 5 ; ++triangleIndex )
{
if (TRIANGLE_CONNECTION_TABLE[ flagIndex ][3 * triangleIndex] < 0)
break;
for ( int triangleVertex = 0 ; triangleVertex < 3 ; ++triangleVertex )
{
int vertexIndex = TRIANGLE_CONNECTION_TABLE[flagIndex][3 * triangleIndex + triangleVertex];
a_pVerts[vertexCount] = edgePosition[ vertexIndex ];
++vertexCount;
}
}
return vertexCount;
}
// marches an entire grid of cubes
unsigned int MarchingCubes::March(const glm::ivec3& a_pCubeCount, const glm::vec3& a_pCubeSize,
float*** a_fVolume, float a_fVolumeThreshold, glm::vec3* a_pVerts,
unsigned int a_uiMaxVerts)
{
unsigned int vertexCount = 0;
for ( int x = 0 ; x < a_pCubeCount.x ; ++x)
{
for ( int y = 0; y < a_pCubeCount.y ; ++y )
{
for ( int z = 0; z < a_pCubeCount.z ; ++z )
{
// as there are potentially 5 new triangles per-cube
// we need to ensure we don't use too many vertices
if ( (vertexCount + 15) >= a_uiMaxVerts)
return vertexCount;
vertexCount += marchCube( glm::ivec3(x,y,z), a_pCubeSize,
a_fVolume, a_fVolumeThreshold,
&a_pVerts[vertexCount] );
}
}
}
return vertexCount;
}
const glm::ivec3 MarchingCubes::CUBE_CORNERS[8] =
{
glm::ivec3(0, 0, 0),glm::ivec3(1, 0, 0),glm::ivec3(1, 1, 0),glm::ivec3(0, 1, 0),
glm::ivec3(0, 0, 1),glm::ivec3(1, 0, 1),glm::ivec3(1, 1, 1),glm::ivec3(0, 1, 1)
};
// EDGE_INDICES lists the index of each vertex for each edge
const int MarchingCubes::EDGE_INDICES[12][2] =
{
{0,1}, {1,2}, {2,3}, {3,0},
{4,5}, {5,6}, {6,7}, {7,4},
{0,4}, {1,5}, {2,6}, {3,7}
};
// EDGE_DIRECTIONS lists the direction that each edge faces
const glm::vec3 MarchingCubes::EDGE_DIRECTIONS[12] =
{
glm::vec3(1.0, 0.0, 0.0),glm::vec3(0.0, 1.0, 0.0),glm::vec3(-1.0, 0.0, 0.0),glm::vec3(0.0, -1.0, 0.0),
glm::vec3(1.0, 0.0, 0.0),glm::vec3(0.0, 1.0, 0.0),glm::vec3(-1.0, 0.0, 0.0),glm::vec3(0.0, -1.0, 0.0),
glm::vec3(0.0, 0.0, 1.0),glm::vec3(0.0, 0.0, 1.0),glm::vec3( 0.0, 0.0, 1.0),glm::vec3(0.0, 0.0, 1.0)
};
//////////////////////////////////////////////////////////////////////////
// The following is open-source
// For any edge, if one vertex is inside of the surface and the other is outside of the surface
// then the edge intersects the surface
// For each of the 8 vertices of the cube can be two possible states : either inside or outside of the surface
// For any cube the are 2^8=256 possible sets of vertex states
// This table lists the edges intersected by the surface for all 256 possible vertex states
// There are 12 edges. For each entry in the table, if edge #n is intersected, then bit #n is set to 1
const int MarchingCubes::CUBE_EDGE_FLAGS[256] =
{
0x000, 0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c, 0x80c, 0x905, 0xa0f, 0xb06, 0xc0a, 0xd03, 0xe09, 0xf00,
0x190, 0x099, 0x393, 0x29a, 0x596, 0x49f, 0x795, 0x69c, 0x99c, 0x895, 0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90,
0x230, 0x339, 0x033, 0x13a, 0x636, 0x73f, 0x435, 0x53c, 0xa3c, 0xb35, 0x83f, 0x936, 0xe3a, 0xf33, 0xc39, 0xd30,
0x3a0, 0x2a9, 0x1a3, 0x0aa, 0x7a6, 0x6af, 0x5a5, 0x4ac, 0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0,
0x460, 0x569, 0x663, 0x76a, 0x066, 0x16f, 0x265, 0x36c, 0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a, 0x963, 0xa69, 0xb60,
0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0x0ff, 0x3f5, 0x2fc, 0xdfc, 0xcf5, 0xfff, 0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0,
0x650, 0x759, 0x453, 0x55a, 0x256, 0x35f, 0x055, 0x15c, 0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53, 0x859, 0x950,
0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6, 0x2cf, 0x1c5, 0x0cc, 0xfcc, 0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0,
0x8c0, 0x9c9, 0xac3, 0xbca, 0xcc6, 0xdcf, 0xec5, 0xfcc, 0x0cc, 0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9, 0x7c0,
0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c, 0x15c, 0x055, 0x35f, 0x256, 0x55a, 0x453, 0x759, 0x650,
0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6, 0xfff, 0xcf5, 0xdfc, 0x2fc, 0x3f5, 0x0ff, 0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0,
0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f, 0xd65, 0xc6c, 0x36c, 0x265, 0x16f, 0x066, 0x76a, 0x663, 0x569, 0x460,
0xca0, 0xda9, 0xea3, 0xfaa, 0x8a6, 0x9af, 0xaa5, 0xbac, 0x4ac, 0x5a5, 0x6af, 0x7a6, 0x0aa, 0x1a3, 0x2a9, 0x3a0,
0xd30, 0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c, 0x53c, 0x435, 0x73f, 0x636, 0x13a, 0x033, 0x339, 0x230,
0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895, 0x99c, 0x69c, 0x795, 0x49f, 0x596, 0x29a, 0x393, 0x099, 0x190,
0xf00, 0xe09, 0xd03, 0xc0a, 0xb06, 0xa0f, 0x905, 0x80c, 0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x000
};
// For each of the possible vertex states listed in aiCubeEdgeFlags there is a specific triangulation
// of the edge intersection points. TRIANGLE_CONNECTION_TABLE lists all of them in the form of
// 0-5 edge triples with the list terminated by the invalid value -1.
// For example: TRIANGLE_CONNECTION_TABLE[3] list the 2 triangles formed when corner[0]
// and corner[1] are inside of the surface, but the rest of the cube is not.
//
// I found this table in an example program someone wrote long ago. It was probably generated by hand
const int MarchingCubes::TRIANGLE_CONNECTION_TABLE[256][16] =
{
{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 8, 3, 9, 8, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 2, 10, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 8, 3, 2, 10, 8, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1},
{3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 11, 2, 8, 11, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 9, 0, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 11, 2, 1, 9, 11, 9, 8, 11, -1, -1, -1, -1, -1, -1, -1},
{3, 10, 1, 11, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 10, 1, 0, 8, 10, 8, 11, 10, -1, -1, -1, -1, -1, -1, -1},
{3, 9, 0, 3, 11, 9, 11, 10, 9, -1, -1, -1, -1, -1, -1, -1},
{9, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 3, 0, 7, 3, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 1, 9, 4, 7, 1, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 4, 7, 3, 0, 4, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1},
{9, 2, 10, 9, 0, 2, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
{2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1, -1, -1, -1},
{8, 4, 7, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 4, 7, 11, 2, 4, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1},
{9, 0, 1, 8, 4, 7, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
{4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, -1, -1, -1, -1},
{3, 10, 1, 3, 11, 10, 7, 8, 4, -1, -1, -1, -1, -1, -1, -1},
{1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, -1, -1, -1, -1},
{4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, -1, -1, -1, -1},
{4, 7, 11, 4, 11, 9, 9, 11, 10, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 4, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 5, 4, 1, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 5, 4, 8, 3, 5, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 8, 1, 2, 10, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
{5, 2, 10, 5, 4, 2, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1},
{2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1, -1, -1, -1},
{9, 5, 4, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 11, 2, 0, 8, 11, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
{0, 5, 4, 0, 1, 5, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
{2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, -1, -1, -1, -1},
{10, 3, 11, 10, 1, 3, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, -1, -1, -1, -1},
{5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, -1, -1, -1, -1},
{5, 4, 8, 5, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1},
{9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1},
{0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1},
{1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 7, 8, 9, 5, 7, 10, 1, 2, -1, -1, -1, -1, -1, -1, -1},
{10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, -1, -1, -1, -1},
{8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, -1, -1, -1, -1},
{2, 10, 5, 2, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1},
{7, 9, 5, 7, 8, 9, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, -1, -1, -1, -1},
{2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, -1, -1, -1, -1},
{11, 2, 1, 11, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, -1, -1, -1, -1},
{5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, -1},
{11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, -1},
{11, 10, 5, 7, 11, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 0, 1, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 8, 3, 1, 9, 8, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
{1, 6, 5, 2, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 6, 5, 1, 2, 6, 3, 0, 8, -1, -1, -1, -1, -1, -1, -1},
{9, 6, 5, 9, 0, 6, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1},
{5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1, -1, -1, -1},
{2, 3, 11, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 0, 8, 11, 2, 0, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
{5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, -1, -1, -1, -1},
{6, 3, 11, 6, 5, 3, 5, 1, 3, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, -1, -1, -1, -1},
{3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1, -1, -1, -1},
{6, 5, 9, 6, 9, 11, 11, 9, 8, -1, -1, -1, -1, -1, -1, -1},
{5, 10, 6, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 3, 0, 4, 7, 3, 6, 5, 10, -1, -1, -1, -1, -1, -1, -1},
{1, 9, 0, 5, 10, 6, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
{10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, -1, -1, -1, -1},
{6, 1, 2, 6, 5, 1, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, -1, -1, -1, -1},
{8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, -1, -1, -1, -1},
{7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, -1},
{3, 11, 2, 7, 8, 4, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
{5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, -1, -1, -1, -1},
{0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1},
{9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, -1},
{8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, -1, -1, -1, -1},
{5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, -1},
{0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, -1},
{6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, -1, -1, -1, -1},
{10, 4, 9, 6, 4, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 10, 6, 4, 9, 10, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1},
{10, 0, 1, 10, 6, 0, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1},
{8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, -1, -1, -1, -1},
{1, 4, 9, 1, 2, 4, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, -1, -1, -1, -1},
{0, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 3, 2, 8, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1},
{10, 4, 9, 10, 6, 4, 11, 2, 3, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, -1, -1, -1, -1},
{3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, -1, -1, -1, -1},
{6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, -1},
{9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, -1, -1, -1, -1},
{8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, -1},
{3, 11, 6, 3, 6, 0, 0, 6, 4, -1, -1, -1, -1, -1, -1, -1},
{6, 4, 8, 11, 6, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 10, 6, 7, 8, 10, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1},
{0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, -1, -1, -1, -1},
{10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, -1, -1, -1, -1},
{10, 6, 7, 10, 7, 1, 1, 7, 3, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1, -1, -1, -1},
{2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, -1},
{7, 8, 0, 7, 0, 6, 6, 0, 2, -1, -1, -1, -1, -1, -1, -1},
{7, 3, 2, 6, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, -1, -1, -1, -1},
{2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, -1},
{1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, -1},
{11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, -1, -1, -1, -1},
{8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, -1},
{0, 9, 1, 11, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, -1, -1, -1, -1},
{7, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 8, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 1, 9, 8, 3, 1, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
{10, 1, 2, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 3, 0, 8, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
{2, 9, 0, 2, 10, 9, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
{6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, -1, -1, -1, -1},
{7, 2, 3, 6, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 0, 8, 7, 6, 0, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1},
{2, 7, 6, 2, 3, 7, 0, 1, 9, -1, -1, -1, -1, -1, -1, -1},
{1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1, -1, -1, -1},
{10, 7, 6, 10, 1, 7, 1, 3, 7, -1, -1, -1, -1, -1, -1, -1},
{10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, -1, -1, -1, -1},
{0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, -1, -1, -1, -1},
{7, 6, 10, 7, 10, 8, 8, 10, 9, -1, -1, -1, -1, -1, -1, -1},
{6, 8, 4, 11, 8, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 6, 11, 3, 0, 6, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1},
{8, 6, 11, 8, 4, 6, 9, 0, 1, -1, -1, -1, -1, -1, -1, -1},
{9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, -1, -1, -1, -1},
{6, 8, 4, 6, 11, 8, 2, 10, 1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, -1, -1, -1, -1},
{4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, -1, -1, -1, -1},
{10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, -1},
{8, 2, 3, 8, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1},
{0, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, -1, -1, -1, -1},
{1, 9, 4, 1, 4, 2, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1},
{8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, -1, -1, -1, -1},
{10, 1, 0, 10, 0, 6, 6, 0, 4, -1, -1, -1, -1, -1, -1, -1},
{4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, -1},
{10, 9, 4, 6, 10, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 5, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 4, 9, 5, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
{5, 0, 1, 5, 4, 0, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
{11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, -1, -1, -1, -1},
{9, 5, 4, 10, 1, 2, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
{6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, -1, -1, -1, -1},
{7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, -1, -1, -1, -1},
{3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, -1},
{7, 2, 3, 7, 6, 2, 5, 4, 9, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, -1, -1, -1, -1},
{3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, -1, -1, -1, -1},
{6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, -1},
{9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, -1, -1, -1, -1},
{1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, -1},
{4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, -1},
{7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, -1, -1, -1, -1},
{6, 9, 5, 6, 11, 9, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1},
{3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1, -1, -1, -1},
{0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, -1, -1, -1, -1},
{6, 11, 3, 6, 3, 5, 5, 3, 1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, -1, -1, -1, -1},
{0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, -1},
{11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, -1},
{6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, -1, -1, -1, -1},
{5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1, -1, -1, -1},
{9, 5, 6, 9, 6, 0, 0, 6, 2, -1, -1, -1, -1, -1, -1, -1},
{1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, -1},
{1, 5, 6, 2, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, -1},
{10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, -1, -1, -1, -1},
{0, 3, 8, 5, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{10, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 5, 10, 7, 5, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 5, 10, 11, 7, 5, 8, 3, 0, -1, -1, -1, -1, -1, -1, -1},
{5, 11, 7, 5, 10, 11, 1, 9, 0, -1, -1, -1, -1, -1, -1, -1},
{10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, -1, -1, -1, -1},
{11, 1, 2, 11, 7, 1, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, -1, -1, -1, -1},
{9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, -1, -1, -1, -1},
{7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, -1},
{2, 5, 10, 2, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1},
{8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, -1, -1, -1, -1},
{9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, -1, -1, -1, -1},
{9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, -1},
{1, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 7, 0, 7, 1, 1, 7, 5, -1, -1, -1, -1, -1, -1, -1},
{9, 0, 3, 9, 3, 5, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1},
{9, 8, 7, 5, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{5, 8, 4, 5, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1},
{5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, -1, -1, -1, -1},
{0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, -1, -1, -1, -1},
{10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, -1},
{2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, -1, -1, -1, -1},
{0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, -1},
{0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, -1},
{9, 4, 5, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1, -1, -1, -1},
{5, 10, 2, 5, 2, 4, 4, 2, 0, -1, -1, -1, -1, -1, -1, -1},
{3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, -1},
{5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, -1, -1, -1, -1},
{8, 4, 5, 8, 5, 3, 3, 5, 1, -1, -1, -1, -1, -1, -1, -1},
{0, 4, 5, 1, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, -1, -1, -1, -1},
{9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 11, 7, 4, 9, 11, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, -1, -1, -1, -1},
{1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, -1, -1, -1, -1},
{3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, -1},
{4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, -1, -1, -1, -1},
{9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, -1},
{11, 7, 4, 11, 4, 2, 2, 4, 0, -1, -1, -1, -1, -1, -1, -1},
{11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, -1, -1, -1, -1},
{2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1, -1, -1, -1},
{9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, -1},
{3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, -1},
{1, 10, 2, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 1, 4, 1, 7, 7, 1, 3, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, -1, -1, -1, -1},
{4, 0, 3, 7, 4, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 9, 3, 9, 11, 11, 9, 10, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 10, 0, 10, 8, 8, 10, 11, -1, -1, -1, -1, -1, -1, -1},
{3, 1, 10, 11, 3, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 11, 1, 11, 9, 9, 11, 8, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, -1, -1, -1, -1},
{0, 2, 11, 8, 0, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 3, 8, 2, 8, 10, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1},
{9, 10, 2, 0, 9, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, -1, -1, -1, -1},
{1, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 3, 8, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}
};
| [
"skweek@live.com"
] | skweek@live.com |
d626a28bf9c591685f95f7c89044f3f4342edb07 | 696e35ccdf167c3f6b1a7f5458406d3bb81987c9 | /chrome/browser/ui/webui/downloads/downloads_list_tracker.h | 7095a71bab3b37c4ec4d1eeff30418bdcdb6d821 | [
"BSD-3-Clause"
] | permissive | mgh3326/iridium-browser | 064e91a5e37f4e8501ea971483bd1c76297261c3 | e7de6a434d2659f02e94917be364a904a442d2d0 | refs/heads/master | 2023-03-30T16:18:27.391772 | 2019-04-24T02:14:32 | 2019-04-24T02:14:32 | 183,128,065 | 0 | 0 | BSD-3-Clause | 2019-11-30T06:06:02 | 2019-04-24T02:04:51 | null | UTF-8 | C++ | false | false | 4,918 | h | // Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_UI_WEBUI_DOWNLOADS_DOWNLOADS_LIST_TRACKER_H_
#define CHROME_BROWSER_UI_WEBUI_DOWNLOADS_DOWNLOADS_LIST_TRACKER_H_
#include <stddef.h>
#include <memory>
#include <set>
#include "base/callback_forward.h"
#include "base/macros.h"
#include "base/strings/string16.h"
#include "base/time/time.h"
#include "base/values.h"
#include "chrome/browser/ui/webui/downloads/downloads.mojom.h"
#include "components/download/content/public/all_download_item_notifier.h"
#include "components/download/public/common/download_item.h"
namespace content {
class DownloadManager;
}
// A class that tracks all downloads activity and keeps a sorted representation
// of the downloads as chrome://downloads wants to display them.
class DownloadsListTracker
: public download::AllDownloadItemNotifier::Observer {
public:
DownloadsListTracker(content::DownloadManager* download_manager,
md_downloads::mojom::PagePtr page);
~DownloadsListTracker() override;
// Clears all downloads on the page if currently sending updates and resets
// chunk tracking data.
void Reset();
// This class only cares about downloads that match |search_terms|.
// An empty list shows all downloads (the default). Returns true if
// |search_terms| differ from the current ones.
bool SetSearchTerms(const std::vector<std::string>& search_terms);
// Starts sending updates and sends a capped amount of downloads. Tracks which
// downloads have been sent. Re-call this to send more.
void StartAndSendChunk();
// Stops sending updates to the page.
void Stop();
content::DownloadManager* GetMainNotifierManager() const;
content::DownloadManager* GetOriginalNotifierManager() const;
// AllDownloadItemNotifier::Observer:
void OnDownloadCreated(content::DownloadManager* manager,
download::DownloadItem* download_item) override;
void OnDownloadUpdated(content::DownloadManager* manager,
download::DownloadItem* download_item) override;
void OnDownloadRemoved(content::DownloadManager* manager,
download::DownloadItem* download_item) override;
protected:
// Testing constructor.
DownloadsListTracker(content::DownloadManager* download_manager,
md_downloads::mojom::PagePtr page,
base::Callback<bool(const download::DownloadItem&)>);
// Creates a dictionary value that's sent to the page as JSON.
virtual md_downloads::mojom::DataPtr CreateDownloadData(
download::DownloadItem* item) const;
// Exposed for testing.
bool IsIncognito(const download::DownloadItem& item) const;
const download::DownloadItem* GetItemForTesting(size_t index) const;
void SetChunkSizeForTesting(size_t chunk_size);
private:
struct StartTimeComparator {
bool operator()(const download::DownloadItem* a,
const download::DownloadItem* b) const;
};
using SortedSet = std::set<download::DownloadItem*, StartTimeComparator>;
// Called by both constructors to initialize common state.
void Init();
// Clears and re-inserts all downloads items into |sorted_items_|.
void RebuildSortedItems();
// Whether |item| should show on the current page.
bool ShouldShow(const download::DownloadItem& item) const;
// Returns the index of |item| in |sorted_items_|.
size_t GetIndex(const SortedSet::iterator& item) const;
// Calls "insertItems" if sending updates and the page knows about |insert|.
void InsertItem(const SortedSet::iterator& insert);
// Calls "updateItem" if sending updates and the page knows about |update|.
void UpdateItem(const SortedSet::iterator& update);
// Removes the item that corresponds to |remove| and sends "removeItems"
// if sending updates.
void RemoveItem(const SortedSet::iterator& remove);
download::AllDownloadItemNotifier main_notifier_;
std::unique_ptr<download::AllDownloadItemNotifier> original_notifier_;
md_downloads::mojom::PagePtr page_;
// Callback used to determine if an item should show on the page. Set to
// |ShouldShow()| in default constructor, passed in while testing.
base::Callback<bool(const download::DownloadItem&)> should_show_;
// When this is true, all changes to downloads that affect the page are sent
// via JavaScript.
bool sending_updates_ = false;
SortedSet sorted_items_;
// The number of items sent to the page so far.
size_t sent_to_page_ = 0u;
// The maximum number of items sent to the page at a time.
size_t chunk_size_ = 20u;
// Current search terms.
std::vector<base::string16> search_terms_;
DISALLOW_COPY_AND_ASSIGN(DownloadsListTracker);
};
#endif // CHROME_BROWSER_UI_WEBUI_DOWNLOADS_DOWNLOADS_LIST_TRACKER_H_
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
f2650104e2e8303ebf793ef36a42355a4fedeee2 | dc2e0d49f99951bc40e323fb92ea4ddd5d9644a0 | /Activemq-cpp_3.7.1/activemq-cpp/src/main/activemq/commands/BaseCommand.h | 664dd4516579443471760622e9285370a4015a6e | [
"Apache-2.0"
] | permissive | wenyu826/CecilySolution | 8696290d1723fdfe6e41ce63e07c7c25a9295ded | 14c4ba9adbb937d0ae236040b2752e2c7337b048 | refs/heads/master | 2020-07-03T06:26:07.875201 | 2016-11-19T07:04:29 | 2016-11-19T07:04:29 | 74,192,785 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,372 | h | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef _ACTIVEMQ_COMMANDS_BASECOMMAND_H_
#define _ACTIVEMQ_COMMANDS_BASECOMMAND_H_
#include <activemq/util/Config.h>
#include <activemq/commands/Command.h>
namespace activemq {
namespace commands {
class AMQCPP_API BaseCommand : public Command {
private:
bool responseRequired;
int commandId;
public:
BaseCommand() : Command(), responseRequired(false), commandId(0) {
}
virtual ~BaseCommand() {}
virtual void setCommandId(int id) {
this->commandId = id;
}
virtual int getCommandId() const {
return commandId;
}
virtual void setResponseRequired(const bool required) {
this->responseRequired = required;
}
virtual bool isResponseRequired() const {
return responseRequired;
}
virtual void copyDataStructure(const DataStructure* src) {
const BaseCommand* command = dynamic_cast<const BaseCommand*> (src);
this->setResponseRequired(command->isResponseRequired());
this->setCommandId(command->getCommandId());
}
/**
* Returns a string containing the information for this DataStructure
* such as its type and value of its elements.
* @return formatted string useful for debugging.
*/
virtual std::string toString() const {
std::ostringstream stream;
stream << "Begin Class = BaseCommand" << std::endl;
stream << BaseDataStructure::toString();
stream << " Response Required = " << responseRequired << std::endl;
stream << " Command Id = " << commandId << std::endl;
stream << "End Class = BaseCommand" << std::endl;
return stream.str();
}
/**
* Compares the DataStructure passed in to this one, and returns if
* they are equivalent. Equivalent here means that they are of the
* same type, and that each element of the objects are the same.
* @returns true if DataStructure's are Equal.
*/
virtual bool equals(const DataStructure* value) const {
return BaseDataStructure::equals(value);
}
virtual bool isBrokerInfo() const {
return false;
}
virtual bool isControlCommand() const {
return false;
}
virtual bool isConnectionControl() const {
return false;
}
virtual bool isConnectionError() const {
return false;
}
virtual bool isConnectionInfo() const {
return false;
}
virtual bool isConsumerInfo() const {
return false;
}
virtual bool isConsumerControl() const {
return false;
}
virtual bool isDestinationInfo() const {
return false;
}
virtual bool isFlushCommand() const {
return false;
}
virtual bool isMessage() const {
return false;
}
virtual bool isMessageAck() const {
return false;
}
virtual bool isMessagePull() const {
return false;
}
virtual bool isKeepAliveInfo() const {
return false;
}
virtual bool isMessageDispatch() const {
return false;
}
virtual bool isMessageDispatchNotification() const {
return false;
}
virtual bool isProducerAck() const {
return false;
}
virtual bool isProducerInfo() const {
return false;
}
virtual bool isResponse() const {
return false;
}
virtual bool isRemoveInfo() const {
return false;
}
virtual bool isRemoveSubscriptionInfo() const {
return false;
}
virtual bool isReplayCommand() const {
return false;
}
virtual bool isSessionInfo() const {
return false;
}
virtual bool isShutdownInfo() const {
return false;
}
virtual bool isTransactionInfo() const {
return false;
}
virtual bool isWireFormatInfo() const {
return false;
}
};
}}
#endif /*_ACTIVEMQ_COMMANDS_BASECOMMAND_H_*/
| [
"626955115@qq.com"
] | 626955115@qq.com |
a8bea2b4ae85853d42b35e782ccbe3260c387fb4 | 596c55c96b1e14140285180cc5559600fe6275aa | /实训代码/MyJob2/MyJob2/main.cpp | 0936605abf68fae0fe42f90dc66dc63cb799915d | [] | no_license | zelda9528/C-code- | 939e82fee7f86012cf7eae618e4dec9ec0421731 | 075fca634e18ec00fdc347033c15c41160e1e52a | refs/heads/master | 2023-08-17T00:51:32.072612 | 2021-09-29T14:23:23 | 2021-09-29T14:23:23 | 287,930,689 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 507 | cpp | // MyJob2.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
using namespace std;
string& replace_all(string& str, const string& old_value, const string& new_value)
{
while (true) {
string::size_type pos(0);
if ((pos = str.find(old_value)) != string::npos)
str.replace(pos, old_value.length(), new_value);
else break;
}
return str;
}
int main()
{
LoginPage Frame;
Frame.CreatePage();
system("pause");
return 0;
}
| [
"2671100876@qq.com"
] | 2671100876@qq.com |
b3ead584e36884b0376e56f8bc3124171cac22ae | 30663cc15919dad4b35ff8e11e7781807d187ee0 | /project_NP/keypadlcd.ino | f217ccf7a355fd922fa0b83b77c001767cb0ed0e | [] | no_license | uni3621/Refresh_git | 088fe80aabc47413084f64e8c277216d6bab7c58 | 80453bb7c80c445590bce784c018e336f95d44f9 | refs/heads/master | 2020-03-18T15:49:30.052776 | 2018-06-22T12:07:14 | 2018-06-22T12:07:14 | 134,930,966 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,779 | ino | #include <LiquidCrystal.h> // include LCD library (standard library)
#include <Keypad.h> // include keypad library - first you must install library (library link in the video description)
// number of the keypad's rows and columns
const byte rows = 4;
const byte cols = 4;
char keyMap [rows] [cols] = { // define the cymbols on the buttons of the keypad
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};
byte rowPins [rows] = {0, 2, 3, 4}; //pins of the keypad
byte colPins [cols] = {5, 6, 7, 8};
Keypad myKeypad = Keypad(makeKeymap(keyMap), rowPins, colPins, rows, cols);
LiquidCrystal lcd (A0, A1, A2, A3, A4, A5); // pins of the LCD. (RS, E, D4, D5, D6, D7)
void setup(){
lcd.begin(16, 2); // 16 * 2 LCD module
Serial.begin(9700);
}
// Set array variable
char Receivedkey[5];
char check[2];
char phone_number[13];
// Set integer variable
int j = 0; // check index
int i = 0; // password index
int k = 0; // ID index
int s = 0; // phone_number index
int x = 0; // total_index
// Set character variable
char *ID = "12345*"; // delivery agent ID
char FIN = '#'; // when close the box
char condition = 'C'; // request only once open
char lcd_condition_1 = 'T'; // first monitor
char lcd_condition_2 = 'T'; // second monitor
char lcd_condition_3 = 'T'; // third monitor
void loop(){
char presskey = myKeypad.getKey(); //define which key is pressed with getKey
if(presskey != 0){
Serial.println(presskey);
}
if(condition == 'C'){
lcd.setCursor(0, 0); // fisrt line
lcd.print("Delivery -> 1*");
lcd.setCursor(0, 1); // second line
lcd.print("Recipient -> 2*");
}
if(Serial.available()){
char in_data;
in_data = Serial.read();
if(in_data == 'D'){
condition = 'D';
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(" Input your ID ");
lcd.setCursor(0, 1);
lcd.print(" then Enter :* ");
}
if(in_data == 'U'){
condition = 'U';
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(" Input your passwd ");
lcd.setCursor(0, 1);
lcd.print(" then Enter :# ");
}
if(in_data == 'W'){
condition = 'W';
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("NOT EXIESTED ID");
lcd.setCursor(0, 1);
lcd.print(" then Enter :# ");
}
if(in_data == 'C'){
condition = 'C';
lcd.setCursor(0, 0); // fisrt line
lcd.print("Delivery -> 1*");
lcd.setCursor(0, 1); // second line
lcd.print("Recipient -> 2*");
}
if(in_data == 'P'){
condition = 'P';
lcd.setCursor(0, 0); // fisrt line
lcd.print("input phone num");
lcd.setCursor(0, 1); // second line
lcd.print("then enter : #");
}
}
}
| [
"39480716+youngsunglee@users.noreply.github.com"
] | 39480716+youngsunglee@users.noreply.github.com |
f6fb843f6dbc2c60ee8eb27c34635f4e294fd98e | 63405a74cb4e4c9a15d39a336319cdf8c076afae | /test/unit/TestBaseSerialPort.h | d6ad0d7eea5a604d6dca44282cc1c5d88966ef8d | [
"MIT"
] | permissive | oddguid/visualstatus | 3fd7e380274a919f3d16fd028eee8a584684ff76 | 0ac831dfb5ce65e5885e06f041b2fd2162a0287a | refs/heads/master | 2016-09-11T01:41:47.778549 | 2015-03-21T15:42:59 | 2015-03-21T15:42:59 | 19,531,067 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,433 | h | #ifndef VST_TESTBASESERIALPORT_H
#define VST_TESTBASESERIALPORT_H
#include <QtTest/QtTest>
#include "../../src/BaseSerialPort.h"
namespace unittest
{
/// Unit tests for BaseSerialPort class.
class TestBaseSerialPort : public QObject
{
Q_OBJECT
private slots:
/// Tests the default constructor.
void defaultConstructor();
/// Tests the error function.
void error();
};
// Dummy class for testing of BaseSerialPort, implements the pure virtual
// functions and makes internals accessible.
class DummySerialPort : public BaseSerialPort
{
Q_OBJECT
public:
explicit DummySerialPort(QObject *parent = nullptr)
: BaseSerialPort(parent)
{
}
virtual ~DummySerialPort()
{
}
virtual bool open(const QString &deviceName,
unsigned int baudrate,
unsigned short timeoutSecs)
{
Q_UNUSED(deviceName)
Q_UNUSED(baudrate)
Q_UNUSED(timeoutSecs)
return true;
}
virtual bool isOpen()
{
return true;
}
virtual bool close()
{
return true;
}
virtual bool setTimeout(unsigned short timeoutSecs)
{
Q_UNUSED(timeoutSecs)
return true;
}
virtual bool write(const QString &data)
{
Q_UNUSED(data)
return true;
}
virtual bool writeRaw(const QByteArray &data)
{
Q_UNUSED(data)
return true;
}
// make m_error accessible
QString &refError()
{
return m_error;
}
};
} // unittest
#endif
| [
"oddguid@oddguid.com"
] | oddguid@oddguid.com |
af0989c5582ba46ee91866bd712601589272aedc | 5a0a4583a7d88c2dd34df2d67b1556e38cba9d68 | /kap41Container_lst177-41unorderedset-init.cpp | f2e06473f92923f6740c2288503fe3743dd87830 | [] | no_license | Paul-Arts/cplus | bde0adc63b2d8f32bb6d209696699d0e08c38511 | 7f90a98bd05f69e8861df99d08011cf042883884 | refs/heads/master | 2020-12-01T02:00:50.339970 | 2019-12-28T00:52:26 | 2019-12-28T00:52:26 | 230,536,999 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,099 | cpp | #include <unordered_set> //#
#include <set>
#include <iostream> //#
using std::unordered_set; using std::cout; //#
template<typename Elem> //#
std::ostream& operator<<=(std::ostream&os, const unordered_set<Elem>&data) { //#
for(auto &e : data) { os << e << ' '; } return os << '\n'; } //#
template<typename Key>
std::set<Key> sorted(const unordered_set<Key> &data)
{ return std::set<Key>(data.begin(), data.end()); }
// ...
int main() { //#
// ohne Argumente
unordered_set<int> leer{};
cout <<= leer; // Ausgabe:
//=
// Initialisierungsliste
unordered_set<int> daten{1,1,2,2,3,3,4,4,5,5};// doppelte werden nicht ?bernommen
cout <<= daten; // Ausgabe in etwa: 5 4 3 2 1
//= 5 4 3 2 1
// Kopie
unordered_set<int> kopie(daten);
cout <<= kopie; // Ausgabe in etwa: 5 4 3 2 1
//= 5 4 3 2 1
// Bereich
auto so1 = sorted(daten);
unordered_set<int> bereich(std::next(so1.begin()), std::prev(so1.end()));
cout <<= bereich; // Ausgabe in etwa: 2 3 4
//= 4 3 2
} //#
| [
"paul@netwerk"
] | paul@netwerk |
8fd61c1c9279902196f3cdb13de73a755df3e164 | 2e852daa4169ed585dd9250b314ddad06500e093 | /labs/lab_4/Rational.cpp | 37f559fdabdfb444e0d98c6a64d739a3bb2296ff | [] | no_license | EmilBaltaevPSTUAsu/info | 6c535ac7daf069eb56a05a4a3c938daad70a2003 | 189f7f46f9bf2f8b63fe0afdc9e7f68f232dc314 | refs/heads/main | 2023-04-14T11:06:39.061295 | 2021-04-19T09:01:50 | 2021-04-19T09:01:50 | 359,393,363 | 0 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 1,671 | cpp | #include "Rational.h"
void Rational::set_first(int f)
{
first = f;
}
void Rational::set_second(int s)
{
if (s == 0) {
cout << "Ошибка знаменателя, равен 0" << endl;
second = 1;
}
else
second = s;
}
Rational& Rational::operator=(const Rational& r)
{
if (&r == this)
return *this;
first = r.first;
second = r.second;
return *this;
}
Rational Rational::operator-(const Rational& r)
{
Rational temp;
// если знаменатели равны)
if (second == r.second) {
temp.first = first - r.first;
temp.second = second;
}
else {
temp.second = second * r.second;
temp.first = first * r.second - r.first * second;
}
return temp;
}
Rational Rational::operator+(const Rational& r)
{
Rational temp;
// если знаменатели равны)
if (second == r.second) {
temp.first = first + r.first;
temp.second = second;
}
else {
temp.second = second * r.second;
temp.first = first * r.second + r.first * second;
}
return temp;
}
Rational Rational::operator*(const Rational& r)
{
Rational temp;
temp.first = first * r.first;
temp.second = second * r.second;
return temp;
}
istream& operator>>(istream& in, Rational& r)
{
int f, s;
cout << "num? "; in >> f; r.set_first(f);
cout << "den? "; in >> s; r.set_second(s);
return in;
}
ostream& operator<<(ostream& out, const Rational& r)
{
if (r.first > 0 && r.second || r.first < 0 && r.second < 0) {
out << abs(r.first) << "/" << abs(r.second);
}
else {
if (r.first < 0 && r.second > 0)
out << r.first << "/" << r.second;
else if (r.first > 0 && r.second < 0)
out << "-" << r.first << "/" << abs(r.second);
}
return out;
}
| [
"swibleperm@gmail.com"
] | swibleperm@gmail.com |
726f757d5e56205b4a70f059f1af982dead28296 | 437ebfc3ee630522b55d94123e00084a24282dd9 | /board.h | 6b9de423e490ceb89259d1203c6dd315dabafcda | [] | no_license | Chesterrific/Picross | b036b62abaa3a31fa4b62bc4194463ddc5c1c90b | ec789f59196c673520fe7951929da0d4b338ab02 | refs/heads/master | 2020-03-08T23:58:13.374601 | 2018-04-06T22:39:31 | 2018-04-06T22:39:31 | 128,477,051 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 971 | h |
#ifndef BOARD_H
#define BOARD_H
#include <fstream>
using namespace std;
const int BOARD_SIZE = 4;
const int HINT_SIZE = 8;
class Board{
private:
int board[BOARD_SIZE][BOARD_SIZE]; //player board
int boardSol[BOARD_SIZE][BOARD_SIZE]; //solution board to be compared to
int columnHints[HINT_SIZE];
int rowHints[HINT_SIZE];
int puzzleNum;
public:
Board(int);
/*
* Board constructor, takes in puzzle number to construct board with
* proper hints and correct solution board.
*/
void ShowBoard();
/*
* Displays board with its hints
*/
void UserInput();
/*
* changes board based on user input
*/
bool Check();
/*
* checks board vs boardSol for correctness
*/
void Save();
/*
* saves user board and puzzle number
*/
void Load();
/*
* loads user board and puzzle
*/
};
#endif /* BOARD_H */
| [
"chesterguinto@gmail.com"
] | chesterguinto@gmail.com |
2805ef13a93470206fc77e4922711d70ec73f40b | 31a95616e23a8fd692bb4bb133a6574f0a5b27ea | /ProjectShell/Source/ProjectShell/ProjectShell.cpp | 6bc9cf3488ddf5d47a6374771565a05ff242b329 | [] | no_license | GimmickPouch/ProjectShell | 749ce98a99e8f88b24d03c83628b840d132ad18c | 79c3772d2526a18a1f36d4cdf260af47334c3331 | refs/heads/master | 2020-04-14T18:49:40.716219 | 2019-05-25T15:16:47 | 2019-05-25T15:16:47 | 164,034,324 | 0 | 0 | null | 2019-05-10T13:03:46 | 2019-01-03T23:41:11 | C++ | UTF-8 | C++ | false | false | 250 | cpp | // Copyright 1998-2018 Epic Games, Inc. All Rights Reserved.
#include "ProjectShell.h"
#include "Modules/ModuleManager.h"
IMPLEMENT_PRIMARY_GAME_MODULE( FDefaultGameModuleImpl, ProjectShell, "ProjectShell" );
DEFINE_LOG_CATEGORY(LogProjectShell)
| [
"luke.alexander.perry@gmail.com"
] | luke.alexander.perry@gmail.com |
c3c9321db845d292fd663612af78bfa623f356fa | 4fefd88ca3a20d926fd5db93b0a18a1e7c06d4d4 | /MWDS/person.h | da4b2cf58234b2400c9cb8e42c2a1b2cde0b0a9c | [] | no_license | shehryarnaeem/SamplePrograms | d59467680166bfc7c1a8ead7b53ec6b70742c0e4 | 982b5fa68a8fa741a43c921c60ed9b0dd48b255a | refs/heads/master | 2021-01-24T06:49:20.819039 | 2017-11-09T10:38:17 | 2017-11-09T10:38:17 | 93,324,203 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 426 | h | #ifndef PERSON_H
#define PERSON_H
#include <QString>
class Person
{
protected:
QString name;
QString address;
QString phone;
public:
Person();
Person(QString,QString,QString);
Person(const Person&);
void set_name(QString);
void set_address(QString);
void set_phone(QString);
QString get_name()const;
QString get_address()const;
QString get_phone()const;
};
#endif // PERSON_H
| [
"heyshutup@gmail.com"
] | heyshutup@gmail.com |
8416c34b520b81b1c19c40439e91010beaa37fa4 | ebc022853bb26cec0b0dbf9b8cfeece26f18f64d | /bitstream.cpp | d32430c07faea456fd4686f6c29572ed3f968688 | [] | no_license | KaiLangen/multihypothesis | 570db69b70a34614d6ab7c2ce885bff1716ef612 | 86f1976c512536bc75e05da67c7f327354947eb6 | refs/heads/master | 2020-04-23T12:51:24.054962 | 2019-06-21T20:15:52 | 2019-06-21T20:15:52 | 171,182,927 | 0 | 0 | null | 2019-06-05T16:47:36 | 2019-02-17T23:07:49 | C++ | UTF-8 | C++ | false | false | 3,549 | cpp | #include <cassert>
#include <iostream>
#include "bitstream.h"
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
Bitstream::Bitstream(int bufferCapacity, FILE* fileHandle)
{
_fileHandle = fileHandle;
_numEmptyBits = 8;
_byteBuffer = 0;
_bufferCapacity = bufferCapacity;
_bufferSize = 0;
_byteCount = 0;
_bitCount = 0;
_readCount = 0;
_streamBuffer = new imgpel[_bufferCapacity];
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
void Bitstream::write(int value, int numBits)
{
unsigned int bitPosition;
if (numBits <= 32) {
bitPosition = 1 << (numBits - 1);
for (int i = 0; i < numBits; i++) {
if (value & bitPosition)
write1Bit(1);
else
write1Bit(0);
bitPosition >>= 1;
}
}
else {
// Pad zeros
for (int i = 0; i < numBits-32; i++)
write1Bit(0);
bitPosition = 1 << 31;
for (int i = 0; i < 32; i++) {
if (value & bitPosition)
write1Bit(1);
else
write1Bit(0);
bitPosition >>= 1;
}
}
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
int Bitstream::read(int numBits)
{
int data = 0;
for (int i = numBits-1; i >= 0; i--)
if (read1Bit())
data |= 1<<i;
_bitCount += numBits;
return data;
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
void Bitstream::write1Bit(int bitValue)
{
_byteBuffer <<= 1;
_byteBuffer |= bitValue;
// If the byte buffer is ready
if (--_numEmptyBits == 0) {
_numEmptyBits = 8;
_streamBuffer[_byteCount++] = _byteBuffer;
_byteBuffer = 0;
// If the stream buffer is full
if (_byteCount == _bufferCapacity) {
fwrite(_streamBuffer, 1, _bufferCapacity, _fileHandle);
_byteCount = 0;
}
}
_bitCount++;
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
bool Bitstream::read1Bit()
{
if (_byteCount == _bufferSize) {
_bufferSize = fread(_streamBuffer, 1, _bufferCapacity, _fileHandle);
if(_bufferSize == 0) {
std::cout<<"bufferCapacity\tbufferSize\tbyteCount\tbitCount\treadCount"<<std::endl;
std::cout<<_bufferCapacity<<"\t\t"<<_bufferSize<<"\t\t";
std::cout<<_byteCount<<"\t\t"<<_bitCount<<"\t\t"<<_readCount<<std::endl;
assert(false);
}
_byteCount = 0;
_byteBuffer = _streamBuffer[_byteCount];
_numEmptyBits = 0;
_readCount++;
}
bool bit = _byteBuffer & (1 << 7);
_byteBuffer <<= 1;
if (++_numEmptyBits == 8) {
_numEmptyBits = 0;
_byteBuffer = _streamBuffer[++_byteCount];
}
return bit;
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
void Bitstream::flush()
{
if (_numEmptyBits < 8 && _numEmptyBits > 0)
_streamBuffer[_byteCount++] = (_byteBuffer << _numEmptyBits);
if (_byteCount != 0)
fwrite(_streamBuffer, 1, _byteCount, _fileHandle);
_byteCount = 0;
_numEmptyBits = 8;
_byteBuffer = 0;
}
| [
"kai.langen@usask.ca"
] | kai.langen@usask.ca |
5e0437b40b74ff682777bd05b6d6432e5db59a77 | 9904f7d5e8a28fd9f863510d5f17cb87d0693295 | /main.cpp | 96b9f9db1fb4d26cab5aa001aa930e1ef1f25a58 | [] | no_license | libra581/QtCheckBox | 62dc08e063ddd4cc378c67758f34f95946cd846b | a83b838be20909458297f5b1e5e05a1443c21ea2 | refs/heads/main | 2023-03-03T09:53:03.840240 | 2021-02-12T06:55:30 | 2021-02-12T06:55:30 | 337,724,301 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,883 | cpp | /*************************************************
*
* Наименование: Пользовательский (кастомный) СheckBox
* Версия: 1.0
* Дата написания: 01.05.2019
* Используемый язык: Qt/C++
* Написал: Семенов Д.С.
*
* Описание цели программы:
* Программа демонстрирует работу с кастомным классом checkbox'a
* myCheckBox, который позволяет задавать свои цвета фона, использует
* кастомную картинку, а также плавно меняет цвета при клике.
*
* Описание структуры программы:
* Для использования myCheckBox, необходимо
* при инициализации задать список из 2 цветов
* (1 - начальный цвет, 2 - конечный цвет).
*
* Платформа: OC Windows
*
**************************************************************
* Программа выполнена в рамках заказа фриланс биржи KWORK. *
**************************************************************
*/
#define stClr QColor(200, 200, 0)
#define endClr QColor(200, 50, 200)
#include <QApplication>
#include <QGridLayout>
#include <QCheckBox>
#include <QLabel>
#include "mycheckbox.h"
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QWidget parent_wdg;
QList<QColor> colors;
colors << stClr << endClr;
myCheckBox *chk_box = new myCheckBox(colors, &parent_wdg);
QGridLayout *grid = new QGridLayout(&parent_wdg);
grid->setMargin(5);
grid->setSpacing(15);
grid->addWidget(chk_box,1,1);
parent_wdg.setLayout(grid);
parent_wdg.show();
return a.exec();
}
| [
"semdima14@mail.ru"
] | semdima14@mail.ru |
73599f8cddc9f575f468249340030956163375d3 | 8cc637d830b30b6c2cddcde8dfcfc6f578e553df | /src/ukf.cpp | 923a853a104d0e255178b4a13ecd31f7f1962b9d | [] | no_license | gauti1311/SFND_Unscented_Kalman_Filter | 5bd1ee0d398d82770aec22c4042adc04c4b9f2c7 | c96583ad69622e2904006312eb23b06b9d53ebdd | refs/heads/master | 2023-02-25T08:22:25.542858 | 2021-01-31T15:16:47 | 2021-01-31T15:16:47 | 256,785,431 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,081 | cpp | #include "ukf.h"
#include "Eigen/Dense"
#include "iostream"
using namespace std;
using Eigen::MatrixXd;
using Eigen::VectorXd;
/**
* Initializes Unscented Kalman filter
*/
UKF::UKF() {
// if this is false, laser measurements will be ignored (except during init)
use_laser_ = true;
// if this is false, radar measurements will be ignored (except during init)
use_radar_ = true;
// initial state vector
x_ = VectorXd(5);
// initial covariance matrix
P_ = MatrixXd(5, 5);
// Process noise standard deviation longitudinal acceleration in m/s^2
std_a_ = 3;
// Process noise standard deviation yaw acceleration in rad/s^2
std_yawdd_ = 2.;
/**
* DO NOT MODIFY measurement noise values below.
* These are provided by the sensor manufacturer.
*/
// Laser measurement noise standard deviation position1 in m
std_laspx_ = 0.15;
// Laser measurement noise standard deviation position2 in m
std_laspy_ = 0.15;
// Radar measurement noise standard deviation radius in m
std_radr_ = 0.3;
// Radar measurement noise standard deviation angle in rad
std_radphi_ = 0.03;
// Radar measurement noise standard deviation radius change in m/s
std_radrd_ = 0.3;
/**
* End DO NOT MODIFY section for measurement noise values
*/
/**
* TODO: Complete the initialization. See ukf.h for other member properties.
* Hint: one or more values initialized above might be wildly off...
*/
n_x_ = 5;
n_aug_ = 7;
Xsig_pred_ = MatrixXd(n_x_, 2 * n_aug_ + 1);
// Define spreading parameter for augmentation
lambda_ = 3 - n_aug_;
weights_ = VectorXd(2 * n_aug_ + 1);
weights_.fill(0.5 / (lambda_ + n_aug_));
weights_(0) = lambda_ / (lambda_ + n_aug_);
// add measurement noise covariance matrix
R_radar_ = MatrixXd(3, 3);
R_radar_.fill(0.0);
R_radar_(0, 0) = std_radr_ * std_radr_;
R_radar_(1, 1) = std_radphi_ * std_radphi_;
R_radar_(2, 2) = std_radrd_ * std_radrd_;
R_lidar_ = MatrixXd(2, 2);
R_lidar_.fill(0.0);
R_lidar_(0, 0) = std_laspx_ * std_laspx_;
R_lidar_(1, 1) = std_laspy_ * std_laspy_;
is_initialized_ = false;
}
UKF::~UKF() {}
void UKF::ProcessMeasurement(MeasurementPackage meas_package) {
/**
* TODO: Complete this function! Make sure you switch between lidar and radar
* measurements.
*/
if (!is_initialized_) {
if (meas_package.sensor_type_ == MeasurementPackage::RADAR) {
double rho = meas_package.raw_measurements_(0);
double phi = meas_package.raw_measurements_(1);
double rho_d = meas_package.raw_measurements_(2);
double p_x = rho * cos(phi);
double p_y = rho * sin(phi);
// To note: this is inaccurate value, aim to initialize velocity which's magnitude/order is close to real value
double vx = rho_d * cos(phi);
double vy = rho_d * sin(phi);
double v = sqrt(vx * vx + vy * vy);
x_ << p_x, p_y, v,0, 0;
P_ << std_radr_ * std_radr_, 0, 0, 0, 0,
0, std_radr_ * std_radr_, 0, 0, 0,
0, 0, std_radrd_ * std_radrd_, 0, 0,
0, 0, 0, std_radphi_, 0,
0, 0, 0, 0, std_radphi_;
} else {
x_ << meas_package.raw_measurements_(0), meas_package.raw_measurements_(1), 0., 0, 0;
P_ << std_laspx_ * std_laspx_, 0, 0, 0, 0,
0, std_laspy_ * std_laspy_, 0, 0, 0,
0, 0, 1, 0, 0,
0, 0, 0, 1, 0,
0, 0, 0, 0, 1;
}
time_us_ = meas_package.timestamp_;
is_initialized_ = true;
std::cout << "Initialization" << std::endl;
return;
}
// compute delta t
double dt = (meas_package.timestamp_ - time_us_)/1000000.0;
time_us_ = meas_package.timestamp_;
// predict step
Prediction(dt);
std::cout << "Prediction" << std::endl;
// update step
if (meas_package.sensor_type_ == MeasurementPackage::RADAR && use_radar_) {
std::cout << "Update Radar" << std::endl;
UpdateRadar(meas_package);
} else if (meas_package.sensor_type_ == MeasurementPackage::LASER && use_laser_) {
std::cout << "Update Lidar" << std::endl;
UpdateLidar(meas_package);
}
}
void UKF::Prediction(double delta_t) {
/**
* TODO: Complete this function! Estimate the object's location.
* Modify the state vector, x_. Predict sigma points, the state,
* and the state covariance matrix.
*/
// std::cout << "Prediction START" << std::endl;
// create augmented mean vector
VectorXd x_aug = VectorXd(n_aug_);
// create augmented state covariance
MatrixXd P_aug = MatrixXd(n_aug_, n_aug_);
P_aug.fill(0.0);
// create sigma point matrix
MatrixXd Xsig_aug = MatrixXd(n_aug_, 2 * n_aug_ + 1);
Xsig_aug.fill(0.0);
// create augmented mean state
x_aug.head(n_x_) = x_;
x_aug(5) = 0;
x_aug(6) = 0;
// create augmented covariance matrix
P_aug.fill(0.0);
P_aug.topLeftCorner(n_x_, n_x_) = P_;
P_aug(5, 5) = std_a_ * std_a_;
P_aug(6, 6) = std_yawdd_ * std_yawdd_;
// create square root matrix
MatrixXd L = P_aug.llt().matrixL();
// create augmented sigma points
Xsig_aug.col(0) = x_aug;
for (int i = 0; i < n_aug_; ++i) {
Xsig_aug.col(i + 1) = x_aug + sqrt(lambda_ + n_aug_) * L.col(i);
Xsig_aug.col(i + 1 + n_aug_) = x_aug - sqrt(lambda_ + n_aug_) * L.col(i);
}
// predict sigma points
for (int i = 0; i < 2 * n_aug_ + 1; ++i) {
// extract values for better readability
double p_x = Xsig_aug(0, i);
double p_y = Xsig_aug(1, i);
double v = Xsig_aug(2, i);
double yaw = Xsig_aug(3, i);
double yawd = Xsig_aug(4, i);
double nu_a = Xsig_aug(5, i);
double nu_yawdd = Xsig_aug(6, i);
// predicted state values
double px_p, py_p;
// avoid division by zero
if (fabs(yawd) > 0.001) {
px_p = p_x + v / yawd * (sin(yaw + yawd * delta_t) - sin(yaw));
py_p = p_y + v / yawd * (cos(yaw) - cos(yaw + yawd * delta_t));
} else {
px_p = p_x + v * delta_t * cos(yaw);
py_p = p_y + v * delta_t * sin(yaw);
}
double v_p = v;
double yaw_p = yaw + yawd * delta_t;
double yawd_p = yawd;
// add noise
px_p = px_p + 0.5 * nu_a * delta_t * delta_t * cos(yaw);
py_p = py_p + 0.5 * nu_a * delta_t * delta_t * sin(yaw);
v_p = v_p + nu_a * delta_t;
yaw_p = yaw_p + 0.5 * nu_yawdd * delta_t * delta_t;
yawd_p = yawd_p + nu_yawdd * delta_t;
// write predicted sigma point into right column
Xsig_pred_(0, i) = px_p;
Xsig_pred_(1, i) = py_p;
Xsig_pred_(2, i) = v_p;
Xsig_pred_(3, i) = yaw_p;
Xsig_pred_(4, i) = yawd_p;
}
//create vector for predicted state
// create covariance matrix for prediction
x_.fill(0.0);
for (int i = 0; i < 2 * n_aug_ + 1; ++i) {
x_ = x_ + weights_(i) * Xsig_pred_.col(i);
}
P_.fill(0.0);
for (int i = 0; i < 2 * n_aug_ + 1; ++i) {
VectorXd x_diff = Xsig_pred_.col(i) - x_;
while (x_diff(3) > M_PI) x_diff(3) -= 2. * M_PI;
while (x_diff(3) < -M_PI) x_diff(3) += 2. * M_PI;
P_ = P_ + weights_(i) * x_diff * x_diff.transpose();
}
}
void UKF::UpdateLidar(MeasurementPackage meas_package) {
/**
* TODO: Complete this function! Use lidar data to update the belief
* about the object's position. Modify the state vector, x_, and
* covariance, P_.
* You can also calculate the lidar NIS, if desired.
*/
// set measurement dimension, px,py
int n_z_ = 2;
// create example vector for incoming lidar measurement
VectorXd z = VectorXd(n_z_);
z << meas_package.raw_measurements_(0),
meas_package.raw_measurements_(1);
// create matrix for sigma points in measurement space
MatrixXd Zsig = MatrixXd(n_z_, 2 * n_aug_ + 1);
// mean predicted measurement
VectorXd z_pred = VectorXd(n_z_);
z_pred.fill(0.0);
// measurement covariance matrix S
MatrixXd S = MatrixXd(n_z_, n_z_);
S.fill(0.0);
// transform sigma points into measurement space
for (int i = 0; i < 2 * n_aug_ + 1; ++i) {
// 2n+1 simga points
// extract values for better readability
double p_x = Xsig_pred_(0, i);
double p_y = Xsig_pred_(1, i);
// measurement model
Zsig(0, i) = p_x;
Zsig(1, i) = p_y;
// mean predicted measurement
z_pred += weights_(i) * Zsig.col(i);
}
// innovation covariance matrix S
for (int i = 0; i < 2 * n_aug_ + 1; ++i) {
// 2n+1 simga points
// residual
VectorXd z_diff = Zsig.col(i) - z_pred;
S += weights_(i) * z_diff * z_diff.transpose();
}
S += R_lidar_;
// create matrix for cross correlation Tc
MatrixXd Tc = MatrixXd(n_x_, n_z_);
Tc.fill(0.0);
for (int i = 0; i < 2 * n_aug_ + 1; ++i) {
// 2n+1 simga points
// residual
VectorXd z_diff = Zsig.col(i) - z_pred;
// state difference
VectorXd x_diff = Xsig_pred_.col(i) - x_;
// normalize angles
while (x_diff(3) > M_PI) x_diff(3) -= 2 * M_PI;
while (x_diff(3) < -M_PI) x_diff(3) += 2 * M_PI;
Tc += weights_(i) * x_diff * z_diff.transpose();
}
// Kalman gain K;
MatrixXd K = Tc * S.inverse();
// residual
VectorXd z_diff = z - z_pred;
// update state mean and covariance matrix
x_ += K * z_diff;
P_ -= K * S * K.transpose();
// compute normalized innovation squared(NIS)
nis_lidar_ = z_diff.transpose() * S.inverse() * z_diff;
}
void UKF::UpdateRadar(MeasurementPackage meas_package) {
/**
* TODO: Complete this function! Use radar data to update the belief
* about the object's position. Modify the state vector, x_, and
* covariance, P_.
* You can also calculate the radar NIS, if desired.
*/
// set measurement dimension, radar can measure r, phi, and r_dot
int n_z_ = 3;
VectorXd z = VectorXd(n_z_);
double meas_rho = meas_package.raw_measurements_(0);
double meas_phi = meas_package.raw_measurements_(1);
double meas_rhod = meas_package.raw_measurements_(2);
z << meas_rho,
meas_phi,
meas_rhod;
// create matrix for sigma points in measurement space
MatrixXd Zsig = MatrixXd(n_z_, 2 * n_aug_ + 1);
// mean predicted measurement
VectorXd z_pred = VectorXd(n_z_);
z_pred.fill(0.0);
// measurement covariance matrix S
MatrixXd S = MatrixXd(n_z_, n_z_);
S.fill(0.0);
// transform sigma points into measurement space
for (int i = 0; i < 2 * n_aug_ + 1; ++i) {
// 2n+1 simga points
// extract values for better readability
double p_x = Xsig_pred_(0, i);
double p_y = Xsig_pred_(1, i);
double v = Xsig_pred_(2, i);
double yaw = Xsig_pred_(3, i);
double v1 = cos(yaw) * v;
double v2 = sin(yaw) * v;
// measurement model
Zsig(0, i) = sqrt(p_x * p_x + p_y * p_y); //r
Zsig(1, i) = atan2(p_y, p_x); // phi
Zsig(2, i) = (p_x * v1 + p_y * v2) / sqrt(p_x * p_x + p_y * p_y); //r_dot
//calculate mean predicted measurement
z_pred += weights_(i) * Zsig.col(i);
}
// innovation covariance matrix S
for (int i = 0; i < 2 * n_aug_ + 1; ++i) {
// 2n+1 simga points
// residual
VectorXd z_diff = Zsig.col(i) - z_pred;
// angle normalization
while (z_diff(1) > M_PI) z_diff(1) -= 2. * M_PI;
while (z_diff(1) < -M_PI) z_diff(1) += 2. * M_PI;
S += weights_(i) * z_diff * z_diff.transpose();
}
S += R_radar_;
// create matrix for cross correlation Tc
MatrixXd Tc = MatrixXd(n_x_, n_z_);
Tc.fill(0.0);
for (int i = 0; i < 2 * n_aug_ + 1; ++i) {
// 2n+1 simga points
// residual
VectorXd z_diff = Zsig.col(i) - z_pred;
// angle normalization
while (z_diff(1) > M_PI) z_diff(1) -= 2. * M_PI;
while (z_diff(1) < -M_PI) z_diff(1) += 2. * M_PI;
// state difference
VectorXd x_diff = Xsig_pred_.col(i) - x_;
// angle normalization
while (x_diff(3) > M_PI) x_diff(3) -= 2. * M_PI;
while (x_diff(3) < -M_PI) x_diff(3) += 2. * M_PI;
Tc += weights_(i) * x_diff * z_diff.transpose();
}
// Kalman gain K;
MatrixXd K = Tc * S.inverse();
// residual
VectorXd z_diff = z - z_pred;
// angle normalization
while (z_diff(1) > M_PI) z_diff(1) -= 2. * M_PI;
while (z_diff(1) < -M_PI) z_diff(1) += 2. * M_PI;
// update state mean and covariance matrix
x_ += K * z_diff;
P_ -= K * S * K.transpose();
// compute normalized innovation squared(NIS)
nis_radar_ = z_diff.transpose() * S.inverse() * z_diff;
} | [
"gautam1311@yahoo.com"
] | gautam1311@yahoo.com |
983ee6b9281d98e5cd95f2c53e3d72e3e3d25bc6 | 6ced41da926682548df646099662e79d7a6022c5 | /aws-cpp-sdk-sagemaker/include/aws/sagemaker/model/AutoMLCandidateGenerationConfig.h | 82ee42ddee2d483b246f8c709a84388eb9ea9489 | [
"Apache-2.0",
"MIT",
"JSON"
] | permissive | irods/aws-sdk-cpp | 139104843de529f615defa4f6b8e20bc95a6be05 | 2c7fb1a048c96713a28b730e1f48096bd231e932 | refs/heads/main | 2023-07-25T12:12:04.363757 | 2022-08-26T15:33:31 | 2022-08-26T15:33:31 | 141,315,346 | 0 | 1 | Apache-2.0 | 2022-08-26T17:45:09 | 2018-07-17T16:24:06 | C++ | UTF-8 | C++ | false | false | 7,531 | h | /**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#pragma once
#include <aws/sagemaker/SageMaker_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>
namespace Aws
{
namespace Utils
{
namespace Json
{
class JsonValue;
class JsonView;
} // namespace Json
} // namespace Utils
namespace SageMaker
{
namespace Model
{
/**
* <p>Stores the config information for how a candidate is generated
* (optional).</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/sagemaker-2017-07-24/AutoMLCandidateGenerationConfig">AWS
* API Reference</a></p>
*/
class AWS_SAGEMAKER_API AutoMLCandidateGenerationConfig
{
public:
AutoMLCandidateGenerationConfig();
AutoMLCandidateGenerationConfig(Aws::Utils::Json::JsonView jsonValue);
AutoMLCandidateGenerationConfig& operator=(Aws::Utils::Json::JsonView jsonValue);
Aws::Utils::Json::JsonValue Jsonize() const;
/**
* <p>A URL to the Amazon S3 data source containing selected features from the
* input data source to run an Autopilot job (optional). This file should be in
* json format as shown below: </p> <p> <code>{ "FeatureAttributeNames":["col1",
* "col2", ...] }</code>.</p> <p>The key name <code>FeatureAttributeNames</code> is
* fixed. The values listed in <code>["col1", "col2", ...]</code> is case sensitive
* and should be a list of strings containing unique values that are a subset of
* the column names in the input data. The list of columns provided must not
* include the target column.</p>
*/
inline const Aws::String& GetFeatureSpecificationS3Uri() const{ return m_featureSpecificationS3Uri; }
/**
* <p>A URL to the Amazon S3 data source containing selected features from the
* input data source to run an Autopilot job (optional). This file should be in
* json format as shown below: </p> <p> <code>{ "FeatureAttributeNames":["col1",
* "col2", ...] }</code>.</p> <p>The key name <code>FeatureAttributeNames</code> is
* fixed. The values listed in <code>["col1", "col2", ...]</code> is case sensitive
* and should be a list of strings containing unique values that are a subset of
* the column names in the input data. The list of columns provided must not
* include the target column.</p>
*/
inline bool FeatureSpecificationS3UriHasBeenSet() const { return m_featureSpecificationS3UriHasBeenSet; }
/**
* <p>A URL to the Amazon S3 data source containing selected features from the
* input data source to run an Autopilot job (optional). This file should be in
* json format as shown below: </p> <p> <code>{ "FeatureAttributeNames":["col1",
* "col2", ...] }</code>.</p> <p>The key name <code>FeatureAttributeNames</code> is
* fixed. The values listed in <code>["col1", "col2", ...]</code> is case sensitive
* and should be a list of strings containing unique values that are a subset of
* the column names in the input data. The list of columns provided must not
* include the target column.</p>
*/
inline void SetFeatureSpecificationS3Uri(const Aws::String& value) { m_featureSpecificationS3UriHasBeenSet = true; m_featureSpecificationS3Uri = value; }
/**
* <p>A URL to the Amazon S3 data source containing selected features from the
* input data source to run an Autopilot job (optional). This file should be in
* json format as shown below: </p> <p> <code>{ "FeatureAttributeNames":["col1",
* "col2", ...] }</code>.</p> <p>The key name <code>FeatureAttributeNames</code> is
* fixed. The values listed in <code>["col1", "col2", ...]</code> is case sensitive
* and should be a list of strings containing unique values that are a subset of
* the column names in the input data. The list of columns provided must not
* include the target column.</p>
*/
inline void SetFeatureSpecificationS3Uri(Aws::String&& value) { m_featureSpecificationS3UriHasBeenSet = true; m_featureSpecificationS3Uri = std::move(value); }
/**
* <p>A URL to the Amazon S3 data source containing selected features from the
* input data source to run an Autopilot job (optional). This file should be in
* json format as shown below: </p> <p> <code>{ "FeatureAttributeNames":["col1",
* "col2", ...] }</code>.</p> <p>The key name <code>FeatureAttributeNames</code> is
* fixed. The values listed in <code>["col1", "col2", ...]</code> is case sensitive
* and should be a list of strings containing unique values that are a subset of
* the column names in the input data. The list of columns provided must not
* include the target column.</p>
*/
inline void SetFeatureSpecificationS3Uri(const char* value) { m_featureSpecificationS3UriHasBeenSet = true; m_featureSpecificationS3Uri.assign(value); }
/**
* <p>A URL to the Amazon S3 data source containing selected features from the
* input data source to run an Autopilot job (optional). This file should be in
* json format as shown below: </p> <p> <code>{ "FeatureAttributeNames":["col1",
* "col2", ...] }</code>.</p> <p>The key name <code>FeatureAttributeNames</code> is
* fixed. The values listed in <code>["col1", "col2", ...]</code> is case sensitive
* and should be a list of strings containing unique values that are a subset of
* the column names in the input data. The list of columns provided must not
* include the target column.</p>
*/
inline AutoMLCandidateGenerationConfig& WithFeatureSpecificationS3Uri(const Aws::String& value) { SetFeatureSpecificationS3Uri(value); return *this;}
/**
* <p>A URL to the Amazon S3 data source containing selected features from the
* input data source to run an Autopilot job (optional). This file should be in
* json format as shown below: </p> <p> <code>{ "FeatureAttributeNames":["col1",
* "col2", ...] }</code>.</p> <p>The key name <code>FeatureAttributeNames</code> is
* fixed. The values listed in <code>["col1", "col2", ...]</code> is case sensitive
* and should be a list of strings containing unique values that are a subset of
* the column names in the input data. The list of columns provided must not
* include the target column.</p>
*/
inline AutoMLCandidateGenerationConfig& WithFeatureSpecificationS3Uri(Aws::String&& value) { SetFeatureSpecificationS3Uri(std::move(value)); return *this;}
/**
* <p>A URL to the Amazon S3 data source containing selected features from the
* input data source to run an Autopilot job (optional). This file should be in
* json format as shown below: </p> <p> <code>{ "FeatureAttributeNames":["col1",
* "col2", ...] }</code>.</p> <p>The key name <code>FeatureAttributeNames</code> is
* fixed. The values listed in <code>["col1", "col2", ...]</code> is case sensitive
* and should be a list of strings containing unique values that are a subset of
* the column names in the input data. The list of columns provided must not
* include the target column.</p>
*/
inline AutoMLCandidateGenerationConfig& WithFeatureSpecificationS3Uri(const char* value) { SetFeatureSpecificationS3Uri(value); return *this;}
private:
Aws::String m_featureSpecificationS3Uri;
bool m_featureSpecificationS3UriHasBeenSet;
};
} // namespace Model
} // namespace SageMaker
} // namespace Aws
| [
"aws-sdk-cpp-automation@github.com"
] | aws-sdk-cpp-automation@github.com |
6fb249b8d995042d86e5b4ddb99a318c090fd18a | 7e21e6f21a53af41f8a87a05aa544b347713c7de | /Activities/Linked List/stackedlinklist.cpp | f3f021dda1c43965858457bc328ee65c15ffb0bb | [] | no_license | subalouis/CPP-Code-Base | 7e96f8967213b51e78754fa20fcb017ae266c3d2 | 803a19fc36c779643ac7ecf9933e8d8198ebd99f | refs/heads/main | 2023-03-07T13:47:08.114485 | 2021-02-17T07:41:50 | 2021-02-17T07:41:50 | 339,597,662 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 419 | cpp | #include <iostream>
#include <stack>
using namespace std;
int main (){
stack <int> stack1,stack2;
for (int i=10;i<=50; i+=10){
stack1.push(i);
stack2.push(i);
}
if (!stack1.empty()){
cout <<"List is Empty!"<<endl;
}
while (!stack1.empty()){
cout<< stack1.top()<<" ";
stack1.pop();
}
cout<< endl;
while (!stack2.empty()){
cout << stack2.top()<< " is removed.\n";
stack2.pop();
}
} | [
"51257898+subalouis@users.noreply.github.com"
] | 51257898+subalouis@users.noreply.github.com |
3dc2563d98d3eb3ee4c9419046f554f4c762fbf8 | 57b7f4d8721504aeb88c715f323e897828436780 | /arduino_code/arduino_code.ino | 4857aea95153b62d93c0092b67fb10bfb9b4e47a | [] | no_license | Youngermaster/Arduino-Car-Controller | fdcca0ef6938a30dacbb32a7f13e422e593dbbca | 0eef65c5546f5236af016f013603c4fafa7d55e0 | refs/heads/master | 2020-09-12T19:12:16.057684 | 2019-12-31T12:12:54 | 2019-12-31T12:12:54 | 222,522,171 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,245 | ino | /**
Car Bluetooth Arduino Controller
Author: Juan Manuel Young Hoyos.
*/
#include <SoftwareSerial.h>
// You can change the pins
#define BLUETOOTH_TX 50
#define BLUETOOTH_TD 51
#define MOTOR_1_A 22
#define MOTOR_1_B 23
#define MOTOR_1_PWM 24
#define MOTOR_2_A 27
#define MOTOR_2_B 28
#define MOTOR_2_PWM 29
const int state_0 = 0;
const int state_1 = 1;
const int state_2 = 2;
const int state_3 = 3;
const int state_4 = 4;
long int data;
SoftwareSerial Blue(BLUETOOTH_TX, BLUETOOTH_TD);
void stopCar() {
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
analogWrite(MOTOR_1_PWM, 0);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(MOTOR_2_PWM, 0);
}
void accelerate() {
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, HIGH);
analogWrite(MOTOR_1_PWM, 2000);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(MOTOR_2_PWM, 0);
}
void reverse() {
digitalWrite(MOTOR_1_A, HIGH);
digitalWrite(MOTOR_1_B, LOW);
analogWrite(MOTOR_1_PWM, 2000);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(MOTOR_2_PWM, 0);
}
void turnRight() {
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, HIGH);
analogWrite(MOTOR_1_PWM, 2000);
digitalWrite(MOTOR_2_A, HIGH);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(MOTOR_2_PWM, 2000);
}
void turnLeft() {
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, HIGH);
analogWrite(MOTOR_1_PWM, 800);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, HIGH);
analogWrite(MOTOR_2_PWM, 800);
}
void setup() {
pinMode(MOTOR_1_A, OUTPUT);
pinMode(MOTOR_1_B, OUTPUT);
pinMode(MOTOR_1_PWM, OUTPUT);
pinMode(MOTOR_2_A, OUTPUT);
pinMode(MOTOR_2_B, OUTPUT);
pinMode(MOTOR_2_PWM, OUTPUT);
stopCar();
Blue.begin(9600);
}
void loop() {
while (Blue.available() == 0);
if (Blue.available() > 0)
data = Blue.parseInt();
switch(data) {
case state_0:
stopCar();
break;
case state_1:
accelerate();
break;
case state_2:
reverse();
break;
case state_3:
turnRight();
break;
case state_4:
turnLeft();
break;
default:
stopCar();
break;
}
}
| [
"jmyoungh@eafit.edu.co"
] | jmyoungh@eafit.edu.co |
1665baf4105f2970a57a4bdc5169753fc7ee22f5 | ddd80bc1939f9e51ab1fd0b883767572fbd5d3b4 | /Week 1/BitManipulation_7.cpp | ae0c3bab9b729afd980803bafa227fa5884cd36e | [] | no_license | preksha121/IPMP | e03c75e5a142557fbd4e05eb31fad4c4532f5c5d | 1b07371bbc9a15f24f2324b89dca3a40d3e2257b | refs/heads/main | 2023-06-05T16:19:05.758340 | 2021-06-25T18:15:03 | 2021-06-25T18:15:03 | 352,301,608 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 236 | cpp | #include <bits/stdc++.h>
using namespace std;
int f(int n)
{
return n & (n - 1);
}
int main()
{
int n;
cin>>n;
cout<<"The number after unsetting the";
cout<<" rightmost set bit "<<f(n);
return 0;
}
| [
"noreply@github.com"
] | preksha121.noreply@github.com |
05e5d3e3df983301f7c20dc2167188300b0d24c0 | 814d5d3d79dbb4468d82a0e57277f57b09a62c17 | /darwin/Framework/include/CM730.h | ff4746eb7ffb1adfbcf5208130330e78ca858566 | [] | no_license | rsmrafael/DarwinWalking-Repository | a64ce41d8a9f80e528fae8296222fa810f292e26 | b08d1fd10d36abb62fa01536de7298e83e69fd58 | refs/heads/master | 2021-01-10T04:30:29.684386 | 2015-10-08T01:06:57 | 2015-10-08T01:06:57 | 43,387,421 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,733 | h | /*
* CM730.h
*
* Author: ROBOTIS
*
*/
#ifndef _CM_730_H_
#define _CM_730_H_
#include "MX28.h"
#define MAXNUM_TXPARAM (256)
#define MAXNUM_RXPARAM (1024)
namespace Robot
{
class BulkReadData
{
public:
int start_address;
int length;
int error;
unsigned char table[MX28::MAXNUM_ADDRESS];
BulkReadData();
virtual ~BulkReadData() {}
int ReadByte(int address);
int ReadWord(int address);
};
class PlatformCM730
{
public:
/////////// Need to implement below methods (Platform porting) //////////////
// Port control
virtual bool OpenPort() = 0;
virtual bool SetBaud(int baud) = 0;
virtual void ClosePort() = 0;
virtual void ClearPort() = 0;
virtual int WritePort(unsigned char* packet, int numPacket) = 0;
virtual int ReadPort(unsigned char* packet, int numPacket) = 0;
// Using semaphore
virtual void LowPriorityWait() = 0;
virtual void MidPriorityWait() = 0;
virtual void HighPriorityWait() = 0;
virtual void LowPriorityRelease() = 0;
virtual void MidPriorityRelease() = 0;
virtual void HighPriorityRelease() = 0;
// Using timeout
virtual void SetPacketTimeout(int lenPacket) = 0;
virtual bool IsPacketTimeout() = 0;
virtual double GetPacketTime() = 0;
virtual void SetUpdateTimeout(int msec) = 0;
virtual bool IsUpdateTimeout() = 0;
virtual double GetUpdateTime() = 0;
virtual void Sleep(double msec) = 0;
//////////////////////////////////////////////////////////////////////////////
};
class CM730
{
public:
enum
{
SUCCESS,
TX_CORRUPT,
TX_FAIL,
RX_FAIL,
RX_TIMEOUT,
RX_CORRUPT
};
enum
{
INPUT_VOLTAGE = 1,
ANGLE_LIMIT = 2,
OVERHEATING = 4,
RANGE = 8,
CHECKSUM = 16,
OVERLOAD = 32,
INSTRUCTION = 64
};
enum
{
P_MODEL_NUMBER_L = 0,
P_MODEL_NUMBER_H = 1,
P_VERSION = 2,
P_ID = 3,
P_BAUD_RATE = 4,
P_RETURN_DELAY_TIME = 5,
P_RETURN_LEVEL = 16,
P_DXL_POWER = 24,
P_LED_PANNEL = 25,
P_LED_HEAD_L = 26,
P_LED_HEAD_H = 27,
P_LED_EYE_L = 28,
P_LED_EYE_H = 29,
P_BUTTON = 30,
P_GYRO_Z_L = 38,
P_GYRO_Z_H = 39,
P_GYRO_Y_L = 40,
P_GYRO_Y_H = 41,
P_GYRO_X_L = 42,
P_GYRO_X_H = 43,
P_ACCEL_X_L = 44,
P_ACCEL_X_H = 45,
P_ACCEL_Y_L = 46,
P_ACCEL_Y_H = 47,
P_ACCEL_Z_L = 48,
P_ACCEL_Z_H = 49,
P_VOLTAGE = 50,
P_LEFT_MIC_L = 51,
P_LEFT_MIC_H = 52,
P_ADC2_L = 53,
P_ADC2_H = 54,
P_ADC3_L = 55,
P_ADC3_H = 56,
P_ADC4_L = 57,
P_ADC4_H = 58,
P_ADC5_L = 59,
P_ADC5_H = 60,
P_ADC6_L = 61,
P_ADC6_H = 62,
P_ADC7_L = 63,
P_ADC7_H = 64,
P_ADC8_L = 65,
P_ADC8_H = 66,
P_RIGHT_MIC_L = 67,
P_RIGHT_MIC_H = 68,
P_ADC10_L = 69,
P_ADC10_H = 70,
P_ADC11_L = 71,
P_ADC11_H = 72,
P_ADC12_L = 73,
P_ADC12_H = 74,
P_ADC13_L = 75,
P_ADC13_H = 76,
P_ADC14_L = 77,
P_ADC14_H = 78,
P_ADC15_L = 79,
P_ADC15_H = 80,
MAXNUM_ADDRESS
};
enum
{
ID_CM = 200,
ID_BROADCAST = 254
};
private:
PlatformCM730 *m_Platform;
static const int RefreshTime = 6; //msec
unsigned char m_ControlTable[MAXNUM_ADDRESS];
unsigned char m_BulkReadTxPacket[MAXNUM_TXPARAM + 10];
int TxRxPacket(unsigned char *txpacket, unsigned char *rxpacket, int priority);
unsigned char CalculateChecksum(unsigned char *packet);
public:
bool DEBUG_PRINT;
BulkReadData m_BulkReadData[ID_BROADCAST];
CM730(PlatformCM730 *platform);
~CM730();
bool Connect();
bool ChangeBaud(int baud);
void Disconnect();
bool DXLPowerOn();
// For board
int WriteByte(int address, int value, int *error);
int WriteWord(int address, int value, int *error);
// For actuators
int Ping(int id, int *error);
int ReadByte(int id, int address, int *pValue, int *error);
int ReadWord(int id, int address, int *pValue, int *error);
int ReadTable(int id, int start_addr, int end_addr, unsigned char *table, int *error);
int WriteByte(int id, int address, int value, int *error);
int WriteWord(int id, int address, int value, int *error);
// For motion control
int SyncWrite(int start_addr, int each_length, int number, int *pParam);
void MakeBulkReadPacket();
int BulkRead();
// Utility
static int MakeWord(int lowbyte, int highbyte);
static int GetLowByte(int word);
static int GetHighByte(int word);
static int MakeColor(int red, int green, int blue);
// *** WEBOTS PART *** //
void MakeBulkReadPacketWb();
};
}
#endif
| [
"rafael.sebatiaomiranda@mail.utoronto.ca"
] | rafael.sebatiaomiranda@mail.utoronto.ca |
31358c652e4d50316c90088a4935641546f3b4b1 | c1deb83dfe59041431114f98445fa02f362fafd0 | /src/10_alignment.cpp | d82766e2c61cf8f0cd1a256e1dcc711768c7e481 | [] | no_license | a-nooj/3d-object-reconstruction-kinect | 8ea7b4a46a123d12a8f859671b9036918995604e | 73e89ec810d924dad7689fb68d081792f316d16a | refs/heads/master | 2022-03-18T07:39:02.195228 | 2019-11-21T17:47:55 | 2019-11-21T17:47:55 | 11,278,433 | 5 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,844 | cpp | #include <vector>
#include <string>
#include <pcl/console/parse.h>
#include <pcl/io/pcd_io.h>
#include <pcl/registration/ia_ransac.h>
#include <pcl/registration/icp.h>
#include <pcl/features/fpfh.h>
#include <pcl/kdtree/kdtree_flann.h>
int main (int argc, char ** argv) {
pcl::PointCloud<pcl::PointXYZRGB>::Ptr source (new pcl::PointCloud<pcl::PointXYZRGB>);
pcl::PointCloud<pcl::PointXYZRGB>::Ptr target (new pcl::PointCloud<pcl::PointXYZRGB>);
pcl::PointCloud<pcl::PointXYZRGB>::Ptr source_keypoints (new pcl::PointCloud<pcl::PointXYZRGB>);
pcl::PointCloud<pcl::PointXYZRGB>::Ptr target_keypoints (new pcl::PointCloud<pcl::PointXYZRGB>);
pcl::PointCloud<pcl::FPFHSignature33>::Ptr source_descriptors (new pcl::PointCloud<pcl::FPFHSignature33>);
pcl::PointCloud<pcl::FPFHSignature33>::Ptr target_descriptors (new pcl::PointCloud<pcl::FPFHSignature33>);
if (argc != 7) {
PCL_ERROR ("Syntax: %s source.pcd sourceKeypoints.pcd sourceDescriptors.pcd target.pcd targetKeypoints.pcd targetDescriptors.pcd\n", argv[0]);
return -1;
}
pcl::io::loadPCDFile (argv[1], *source);
std::string inputfile = argv[1];
std::cout << "Loaded "
<< source->width * source->height
<< " data points from " << inputfile << "."
<< std::endl;
pcl::io::loadPCDFile (argv[2], *source_keypoints);
inputfile = argv[2];
std::cout << "Loaded "
<< source_keypoints->width * source_keypoints->height
<< " data points from " << inputfile << "."
<< std::endl;
pcl::io::loadPCDFile (argv[3], *source_descriptors);
inputfile = argv[3];
std::cout << "Loaded "
<< source_descriptors->width * source_descriptors->height
<< " data points from " << inputfile << "."
<< std::endl;
pcl::io::loadPCDFile (argv[4], *target);
inputfile = argv[4];
std::cout << "Loaded "
<< target->width * target->height
<< " data points from " << inputfile << "."
<< std::endl;
pcl::io::loadPCDFile (argv[5], *target_keypoints);
inputfile = argv[5];
std::cout << "Loaded "
<< target_keypoints->width * target_keypoints->height
<< " data points from " << inputfile << "."
<< std::endl;
pcl::io::loadPCDFile (argv[6], *target_descriptors);
inputfile = argv[6];
std::cout << "Loaded "
<< target_descriptors->width * target_descriptors->height
<< " data points from " << inputfile << "."
<< std::endl;
Eigen::Matrix4f initial_alignment = Eigen::Matrix4f::Identity ();
Eigen::Matrix4f final_alignment = Eigen::Matrix4f::Identity ();
float min_sample_distance = 0.025;
float max_correspondence_distance = 0.01;
int nr_iterations = 500;
pcl::SampleConsensusInitialAlignment<pcl::PointXYZRGB, pcl::PointXYZRGB, pcl::FPFHSignature33> sac_ia;
sac_ia.setMinSampleDistance (min_sample_distance);
sac_ia.setMaxCorrespondenceDistance (max_correspondence_distance);
sac_ia.setMaximumIterations (nr_iterations);
sac_ia.setInputCloud (source_keypoints);
sac_ia.setSourceFeatures (source_descriptors);
sac_ia.setInputTarget (target_keypoints);
sac_ia.setTargetFeatures (target_descriptors);
pcl::PointCloud<pcl::PointXYZRGB>::Ptr aligned_source (new pcl::PointCloud<pcl::PointXYZRGB>);
sac_ia.align (*aligned_source);
initial_alignment = sac_ia.getFinalTransformation();
pcl::console::print_info ("Computed initial alignment\n");
float max_correspondence_distance_refine = 0.05;
float outlier_rejection_threshold = 0.05;
float transformation_epsilon = 1e-6;
int max_iterations = 1000;
pcl::IterativeClosestPoint<pcl::PointXYZRGB, pcl::PointXYZRGB> icp;
icp.setMaxCorrespondenceDistance (max_correspondence_distance);
icp.setRANSACOutlierRejectionThreshold (outlier_rejection_threshold);
icp.setTransformationEpsilon (transformation_epsilon);
icp.setMaximumIterations (max_iterations);
//pcl::PointCloud<pcl::PointXYZRGB>::Ptr source_points_transformed (new pcl::PointCloud<pcl::PointXYZRGB>);
//pcl::transformPointCloud (*source, *source_points_transformed, initial_alignment);
icp.setInputCloud (aligned_source);
icp.setInputTarget (target);
pcl::PointCloud<pcl::PointXYZRGB> registration_output;
icp.align (registration_output);
final_alignment = icp.getFinalTransformation () * initial_alignment;
pcl::console::print_info ("Refined alignment\n");
// Transform the source point to align them with the target points
pcl::transformPointCloud (*source, *source, final_alignment);
// Save output
//std::string filename;
// Merge the two clouds
(*source) += (*target);
std::string delimiter = ".pcd";
std::string outfile = "finalAlignedCloud" + inputfile.substr(inputfile.find(delimiter) - 1, inputfile.find('\0'));
pcl::io::savePCDFileASCII (outfile, *source);
std::cerr << "Saved "
<< source->width * source->height
<< " data points to " << outfile << "."
<< std::endl;
return (0);
}
| [
"anujpasricha01@gmail.com"
] | anujpasricha01@gmail.com |
761014eec206d463ccba51885bd7b5094d48389a | a15950e54e6775e6f7f7004bb90a5585405eade7 | /ui/app_list/views/expand_arrow_view.cc | 4fb6d2dfe0d7a3d9c3f1883434b6d6421d339bdb | [
"BSD-3-Clause"
] | permissive | whycoding126/chromium | 19f6b44d0ec3e4f1b5ef61cc083cae587de3df73 | 9191e417b00328d59a7060fa6bbef061a3fe4ce4 | refs/heads/master | 2023-02-26T22:57:28.582142 | 2018-04-09T11:12:57 | 2018-04-09T11:12:57 | 128,760,157 | 1 | 0 | null | 2018-04-09T11:17:03 | 2018-04-09T11:17:03 | null | UTF-8 | C++ | false | false | 10,734 | cc | // Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ui/app_list/views/expand_arrow_view.h"
#include <memory>
#include <utility>
#include "base/bind.h"
#include "base/metrics/histogram_macros.h"
#include "base/threading/thread_task_runner_handle.h"
#include "ui/app_list/app_list_constants.h"
#include "ui/app_list/vector_icons/vector_icons.h"
#include "ui/app_list/views/app_list_view.h"
#include "ui/app_list/views/contents_view.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/gfx/animation/slide_animation.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/paint_vector_icon.h"
#include "ui/strings/grit/ui_strings.h"
#include "ui/views/animation/flood_fill_ink_drop_ripple.h"
#include "ui/views/animation/ink_drop_impl.h"
#include "ui/views/animation/ink_drop_mask.h"
#include "ui/views/animation/ink_drop_painted_layer_delegates.h"
#include "ui/views/controls/image_view.h"
namespace app_list {
namespace {
constexpr int kExpandArrowTileSize = 60;
constexpr int kExpandArrowIconSize = 12;
constexpr int kClipViewSize = 36;
constexpr int kInkDropRadius = 18;
constexpr int kSelectedRadius = 18;
// Animation related constants
constexpr int kPulseMinRadius = 2;
constexpr int kPulseMaxRadius = 30;
constexpr float kPulseMinOpacity = 0.f;
constexpr float kPulseMaxOpacity = 0.3f;
constexpr int kAnimationInitialWaitTimeInSec = 3;
constexpr int kAnimationIntervalInSec = 10;
constexpr int kCycleDurationInMs = 1000;
constexpr int kCycleIntervalInMs = 500;
constexpr int kPulseOpacityShowBeginTimeInMs = 100;
constexpr int kPulseOpacityShowEndTimeInMs = 200;
constexpr int kPulseOpacityHideBeginTimeInMs = 800;
constexpr int kPulseOpacityHideEndTimeInMs = 1000;
constexpr int kArrowMoveOutBeginTimeInMs = 100;
constexpr int kArrowMoveOutEndTimeInMs = 500;
constexpr int kArrowMoveInBeginTimeInMs = 500;
constexpr int kArrowMoveInEndTimeInMs = 900;
constexpr SkColor kExpandArrowColor = SK_ColorWHITE;
constexpr SkColor kPulseColor = SK_ColorWHITE;
constexpr SkColor kUnFocusedBackgroundColor =
SkColorSetARGBMacro(0xF, 0xFF, 0xFF, 0xFF);
constexpr SkColor kFocusedBackgroundColor =
SkColorSetARGBMacro(0x3D, 0xFF, 0xFF, 0xFF);
constexpr SkColor kInkDropRippleColor =
SkColorSetARGBMacro(0x14, 0xFF, 0xFF, 0xFF);
} // namespace
ExpandArrowView::ExpandArrowView(ContentsView* contents_view,
AppListView* app_list_view)
: views::Button(this),
contents_view_(contents_view),
app_list_view_(app_list_view),
weak_ptr_factory_(this) {
SetFocusBehavior(FocusBehavior::ALWAYS);
SetPaintToLayer();
layer()->SetFillsBoundsOpaquely(false);
icon_ = new views::ImageView;
icon_->SetVerticalAlignment(views::ImageView::CENTER);
icon_->SetImage(gfx::CreateVectorIcon(kIcArrowUpIcon, kExpandArrowIconSize,
kExpandArrowColor));
clip_view_ = new views::View;
clip_view_->AddChildView(icon_);
AddChildView(clip_view_);
SetInkDropMode(InkDropHostView::InkDropMode::ON);
SetAccessibleName(l10n_util::GetStringUTF16(IDS_APP_LIST_EXPAND_BUTTON));
animation_.reset(new gfx::SlideAnimation(this));
animation_->SetTweenType(gfx::Tween::LINEAR);
animation_->SetSlideDuration(kCycleDurationInMs * 2 + kCycleIntervalInMs);
ResetHintingAnimation();
ScheduleHintingAnimation(true);
}
ExpandArrowView::~ExpandArrowView() = default;
void ExpandArrowView::PaintButtonContents(gfx::Canvas* canvas) {
gfx::Rect rect(GetContentsBounds());
// Draw focused or unfocused background.
cc::PaintFlags flags;
flags.setAntiAlias(true);
flags.setColor(HasFocus() ? kFocusedBackgroundColor
: kUnFocusedBackgroundColor);
flags.setStyle(cc::PaintFlags::kFill_Style);
canvas->DrawCircle(gfx::PointF(rect.CenterPoint()), kSelectedRadius, flags);
if (animation_->is_animating()) {
cc::PaintFlags flags;
flags.setStyle(cc::PaintFlags::kStroke_Style);
flags.setColor(SkColorSetA(kPulseColor, 255 * pulse_opacity_));
flags.setAntiAlias(true);
canvas->DrawCircle(rect.CenterPoint(), pulse_radius_, flags);
}
}
void ExpandArrowView::ButtonPressed(views::Button* sender,
const ui::Event& event) {
button_pressed_ = true;
ResetHintingAnimation();
TransitToFullscreenAllAppsState();
GetInkDrop()->AnimateToState(views::InkDropState::ACTION_TRIGGERED);
}
gfx::Size ExpandArrowView::CalculatePreferredSize() const {
return gfx::Size(kExpandArrowTileSize, kExpandArrowTileSize);
}
void ExpandArrowView::Layout() {
gfx::Rect clip_view_rect(GetContentsBounds());
clip_view_rect.ClampToCenteredSize(gfx::Size(kClipViewSize, kClipViewSize));
clip_view_->SetBoundsRect(clip_view_rect);
gfx::Rect icon_rect(clip_view_->GetContentsBounds());
icon_rect.ClampToCenteredSize(
gfx::Size(kExpandArrowIconSize, kExpandArrowIconSize));
icon_->SetBoundsRect(icon_rect);
}
bool ExpandArrowView::OnKeyPressed(const ui::KeyEvent& event) {
if (event.key_code() != ui::VKEY_RETURN)
return false;
TransitToFullscreenAllAppsState();
return true;
}
void ExpandArrowView::OnFocus() {
SchedulePaint();
Button::OnFocus();
}
void ExpandArrowView::OnBlur() {
SchedulePaint();
Button::OnBlur();
}
std::unique_ptr<views::InkDrop> ExpandArrowView::CreateInkDrop() {
std::unique_ptr<views::InkDropImpl> ink_drop =
Button::CreateDefaultInkDropImpl();
ink_drop->SetShowHighlightOnHover(false);
ink_drop->SetShowHighlightOnFocus(false);
ink_drop->SetAutoHighlightMode(views::InkDropImpl::AutoHighlightMode::NONE);
return std::move(ink_drop);
}
std::unique_ptr<views::InkDropMask> ExpandArrowView::CreateInkDropMask() const {
return std::make_unique<views::CircleInkDropMask>(
size(), GetLocalBounds().CenterPoint(), kInkDropRadius);
}
std::unique_ptr<views::InkDropRipple> ExpandArrowView::CreateInkDropRipple()
const {
gfx::Point center = GetLocalBounds().CenterPoint();
gfx::Rect bounds(center.x() - kInkDropRadius, center.y() - kInkDropRadius,
2 * kInkDropRadius, 2 * kInkDropRadius);
return std::make_unique<views::FloodFillInkDropRipple>(
size(), GetLocalBounds().InsetsFrom(bounds),
GetInkDropCenterBasedOnLastEvent(), kInkDropRippleColor, 1.0f);
}
void ExpandArrowView::AnimationProgressed(const gfx::Animation* animation) {
// There are two cycles in one animation.
const int animation_duration = kCycleDurationInMs * 2 + kCycleIntervalInMs;
const int first_cycle_end_time = kCycleDurationInMs;
const int interval_end_time = kCycleDurationInMs + kCycleIntervalInMs;
const int second_cycle_end_time = kCycleDurationInMs * 2 + kCycleIntervalInMs;
int time_in_ms = animation->GetCurrentValue() * animation_duration;
if (time_in_ms > first_cycle_end_time && time_in_ms <= interval_end_time) {
// There's no animation in the interval between cycles.
return;
} else if (time_in_ms > interval_end_time &&
time_in_ms <= second_cycle_end_time) {
// Convert to time in one single cycle.
time_in_ms -= interval_end_time;
}
// Update pulse opacity.
if (time_in_ms > kPulseOpacityShowBeginTimeInMs &&
time_in_ms <= kPulseOpacityShowEndTimeInMs) {
pulse_opacity_ =
kPulseMinOpacity +
(kPulseMaxOpacity - kPulseMinOpacity) *
(time_in_ms - kPulseOpacityShowBeginTimeInMs) /
(kPulseOpacityShowEndTimeInMs - kPulseOpacityShowBeginTimeInMs);
} else if (time_in_ms > kPulseOpacityHideBeginTimeInMs &&
time_in_ms <= kPulseOpacityHideEndTimeInMs) {
pulse_opacity_ =
kPulseMaxOpacity -
(kPulseMaxOpacity - kPulseMinOpacity) *
(time_in_ms - kPulseOpacityHideBeginTimeInMs) /
(kPulseOpacityHideEndTimeInMs - kPulseOpacityHideBeginTimeInMs);
}
// Update pulse radius.
pulse_radius_ = static_cast<float>(kPulseMaxRadius - kPulseMinRadius) *
gfx::Tween::CalculateValue(
gfx::Tween::EASE_IN_OUT,
static_cast<double>(time_in_ms) / kCycleDurationInMs);
// Update y position of the arrow icon.
int y_position = icon_->bounds().y();
const int total_y_delta = (kExpandArrowTileSize - kExpandArrowIconSize) / 2;
if (time_in_ms > kArrowMoveOutBeginTimeInMs &&
time_in_ms <= kArrowMoveOutEndTimeInMs) {
const double progress =
static_cast<double>(time_in_ms - kArrowMoveOutBeginTimeInMs) /
(kArrowMoveOutEndTimeInMs - kArrowMoveOutBeginTimeInMs);
y_position = (kClipViewSize - kExpandArrowIconSize) / 2 -
total_y_delta *
gfx::Tween::CalculateValue(gfx::Tween::EASE_IN, progress);
} else if (time_in_ms > kArrowMoveInBeginTimeInMs &&
time_in_ms <= kArrowMoveInEndTimeInMs) {
const double progress =
static_cast<double>(time_in_ms - kArrowMoveInBeginTimeInMs) /
(kArrowMoveInEndTimeInMs - kArrowMoveInBeginTimeInMs);
y_position = (kClipViewSize - kExpandArrowIconSize) / 2 +
total_y_delta * (1 - gfx::Tween::CalculateValue(
gfx::Tween::EASE_OUT, progress));
}
// Apply updates.
gfx::Rect icon_rect(icon_->bounds());
icon_rect.set_y(y_position);
icon_->SetBoundsRect(icon_rect);
SchedulePaint();
}
void ExpandArrowView::AnimationEnded(const gfx::Animation* animation) {
ResetHintingAnimation();
if (!button_pressed_)
ScheduleHintingAnimation(false);
}
void ExpandArrowView::TransitToFullscreenAllAppsState() {
UMA_HISTOGRAM_ENUMERATION(kPageOpenedHistogram, ash::AppListState::kStateApps,
ash::AppListState::kStateLast);
UMA_HISTOGRAM_ENUMERATION(kAppListPeekingToFullscreenHistogram, kExpandArrow,
kMaxPeekingToFullscreen);
contents_view_->SetActiveState(ash::AppListState::kStateApps);
app_list_view_->SetState(AppListViewState::FULLSCREEN_ALL_APPS);
}
void ExpandArrowView::ScheduleHintingAnimation(bool is_first_time) {
int delay_in_sec = kAnimationIntervalInSec;
if (is_first_time)
delay_in_sec = kAnimationInitialWaitTimeInSec;
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
base::BindOnce(&ExpandArrowView::StartHintingAnimation,
weak_ptr_factory_.GetWeakPtr()),
base::TimeDelta::FromSeconds(delay_in_sec));
}
void ExpandArrowView::StartHintingAnimation() {
if (!button_pressed_)
animation_->Show();
}
void ExpandArrowView::ResetHintingAnimation() {
pulse_opacity_ = kPulseMinOpacity;
pulse_radius_ = kPulseMinRadius;
animation_->Reset();
Layout();
}
} // namespace app_list
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
15e825db78ab9c0381014aeca8c37cc8922cb7b7 | 68bd54635d86cbf9661551e2117c0bf7a452fb54 | /test_1/test_1_git/main.cpp | f24ae493cbd203bd159fe0f173c9af551c1d059a | [] | no_license | Jurgen1313/test | e104b3dac64c7e20ea7bda1d3d5cc197eda30f10 | c0a155807cea956926617ebb6ffe9082c6d6b528 | refs/heads/master | 2021-01-21T09:38:12.080833 | 2017-07-19T18:44:23 | 2017-07-19T18:44:23 | 91,661,739 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 283 | cpp | #include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
cout << "Hello World!" << endl;
cout << "Test project 1" << endl;
cout << "Test project 2" << endl;
cout << "Test project 3" << endl;
cout << "Test project 4" << endl;
return 0;
}
| [
"jazuk.jurij@gmail.com"
] | jazuk.jurij@gmail.com |
fdd331340b0ceccd4b8c5b2c3eaacc9dc802ed0f | 5f3f9360eb91b7c6d9032d4897b092705325a6af | /1611/main.cpp | 8ebe5101fa0a0a247e5135fc5ad00e8e2f688377 | [] | no_license | luigidcsoares/uri | ff2cb2ad63a79f22b672ebe780d3cad892b2df0a | a41bd2c7f9f32553110e2b698543fd14858b203b | refs/heads/master | 2022-12-27T14:30:15.536559 | 2020-10-11T23:21:25 | 2020-10-11T23:21:25 | 303,012,518 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,715 | cpp | #include <iostream>
using namespace std;
// Note: Cormen 3ed. (english), page 31 (modified a little bit to sort in
// descending order).
void merge(int *A, int p, int q, int r) {
int n1 = q - p + 1;
int n2 = r - q;
int L[n1 + 1], R[n2 + 1];
for (int i = 0; i < n1; i++) L[i] = A[p + i];
for (int j = 0; j < n2; j++) R[j] = A[q + j + 1];
L[n1] = R[n2] = -1;
int i = 0, j = 0;
for (int k = p; k <= r; k++) {
if (L[i] > R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
// Sort array A in >> descending << order.
// Note: Cormen 3ed. (english), page 34.
void mergesort(int *A, int p, int r) {
if (p < r) {
int q = (p + r) / 2;
mergesort(A, p, q);
mergesort(A, q + 1, r);
merge(A, p, q, r);
}
}
// We can reduce the problem of finding the minimum energy used by the
// elevator to something similar to sorting the floors that each person
// want to go.
//
// The base case (trivial case) of the problem happens when M <= C. That is,
// the group of M people can use the elevador at the same time. In this case,
// the solution is the maximum floor times 2 (since the elevator must return to
// the floor 0).
//
// Assume that M > C. Then, there will be groups of people using the elevator
// together. Consider two groups A and B. Let min{A} be the minimum floor in A,
// and max{A} the maximum floor (similar to B). The cost of the two groups will
// be 2 * (max{A} + max{B}). Now, consider that max{A} > min{B}. If we move
// max{A} to B (name it B') and min{B} to A (name it A'), we end up with a cost
// 2 * {max{A'} + max{B'}}. Note that max{A'} < max{A} and max{B'} =
// max{max{A}, max{B}}. Clearly, we have reduced the cost of energy.
//
// In order words, we can reduce this to a sorting problem. We sort the floors
// in descending order, because it is better to let a smaller group of people
// using the elevator to go the minimum floor than to go to the maximum.
// Consider the situation where groups does not have the same number of people.
// For instance, assume that there K groups of C people and 1 people lefting.
// The cost will be minimized if we let this last people go to the minimum
// floor than to the maximum. To clarify, consider the following input:
//
// C = 2, M = 3 and floors = [1, 2, 3]. If we sort in ascending order (it is
// already sorted), we have two groups: {1, 2} and {3}. The cost of the first
// is 2 * 2 = 4. The cost of the second is 3 * 2 = 6. Hence, the total cost is
// 6 + 4 = 10. If instead, we sort in descending order (i.e. 3, 2, 1), the
// first group would be {3, 2} and the second {1}. The cost of the first is 3 *
// 2 = 6, while the cost of the second is 2 * 1 = 1. Thus, the total cost is 6
// + 2 = 8 < 10. The main observation is that >> we will have to move the
// elevator to the maximum floor at some point <<, so it is better to take
// together people that will go to floors as close as possible to the maximum.
int minEnergy(int C, int M, int *floors) {
// Theta(M·log M)
mergesort(floors, 0, M - 1);
int sum = 0;
// O(M) -- the worst case happens when C = 1.
for (int i = 0; i < M; i += C) sum += 2 * floors[i];
// Therefore, the final complexity is O(M·log M).
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
for (int i = 0; i < T; i++) {
int N, C, M;
cin >> N; // Not used :/
cin >> C;
cin >> M;
int floors[M];
for (int i = 0; i < M; i++) cin >> floors[i];
cout << minEnergy(C, M, floors) << "\n";
}
return 0;
}
| [
"luigidcsoares@gmail.com"
] | luigidcsoares@gmail.com |
4559723d20df457472c52594a35e739139edd1cf | 8ecdbfc9e5ec00098200cb0335a97ee756ffab61 | /games-generated/Stencyl_Vertical_Shooter/Export/windows/obj/src/openfl/errors/IOError.cpp | 7db171f36d200a9b09701777b377edf3a2d78726 | [] | no_license | elsandkls/Stencyl_VerticalSpaceShooter | 89ccaafe717297a2620d6b777441e67f8751f0ec | 87e501dcca05eaa5f8aeacc9f563b5d5080ffb53 | refs/heads/master | 2021-07-06T11:08:31.016728 | 2020-10-01T05:57:11 | 2020-10-01T05:57:11 | 184,013,592 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | true | 3,314 | cpp | // Generated by Haxe 3.4.7
#include <hxcpp.h>
#ifndef INCLUDED_openfl_errors_Error
#include <openfl/errors/Error.h>
#endif
#ifndef INCLUDED_openfl_errors_IOError
#include <openfl/errors/IOError.h>
#endif
HX_DEFINE_STACK_FRAME(_hx_pos_f56cae0bb14fb04e_13_new,"openfl.errors.IOError","new",0xdfaba8cf,"openfl.errors.IOError.new","openfl/errors/IOError.hx",13,0x640bffa1)
namespace openfl{
namespace errors{
void IOError_obj::__construct(::String __o_message){
::String message = __o_message.Default(HX_HCSTRING("","\x00","\x00","\x00","\x00"));
HX_STACKFRAME(&_hx_pos_f56cae0bb14fb04e_13_new)
HXLINE( 15) super::__construct(message,null());
HXLINE( 17) this->name = HX_("IOError",02,9a,27,78);
}
Dynamic IOError_obj::__CreateEmpty() { return new IOError_obj; }
void *IOError_obj::_hx_vtable = 0;
Dynamic IOError_obj::__Create(hx::DynamicArray inArgs)
{
hx::ObjectPtr< IOError_obj > _hx_result = new IOError_obj();
_hx_result->__construct(inArgs[0]);
return _hx_result;
}
bool IOError_obj::_hx_isInstanceOf(int inClassId) {
if (inClassId<=(int)0x1fc85c4d) {
return inClassId==(int)0x00000001 || inClassId==(int)0x1fc85c4d;
} else {
return inClassId==(int)0x382d061f;
}
}
hx::ObjectPtr< IOError_obj > IOError_obj::__new(::String __o_message) {
hx::ObjectPtr< IOError_obj > __this = new IOError_obj();
__this->__construct(__o_message);
return __this;
}
hx::ObjectPtr< IOError_obj > IOError_obj::__alloc(hx::Ctx *_hx_ctx,::String __o_message) {
IOError_obj *__this = (IOError_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(IOError_obj), true, "openfl.errors.IOError"));
*(void **)__this = IOError_obj::_hx_vtable;
__this->__construct(__o_message);
return __this;
}
IOError_obj::IOError_obj()
{
}
#if HXCPP_SCRIPTABLE
static hx::StorageInfo *IOError_obj_sMemberStorageInfo = 0;
static hx::StaticInfo *IOError_obj_sStaticStorageInfo = 0;
#endif
static void IOError_obj_sMarkStatics(HX_MARK_PARAMS) {
HX_MARK_MEMBER_NAME(IOError_obj::__mClass,"__mClass");
};
#ifdef HXCPP_VISIT_ALLOCS
static void IOError_obj_sVisitStatics(HX_VISIT_PARAMS) {
HX_VISIT_MEMBER_NAME(IOError_obj::__mClass,"__mClass");
};
#endif
hx::Class IOError_obj::__mClass;
void IOError_obj::__register()
{
hx::Object *dummy = new IOError_obj;
IOError_obj::_hx_vtable = *(void **)dummy;
hx::Static(__mClass) = new hx::Class_obj();
__mClass->mName = HX_HCSTRING("openfl.errors.IOError","\x5d","\x95","\xbd","\x5d");
__mClass->mSuper = &super::__SGetClass();
__mClass->mConstructEmpty = &__CreateEmpty;
__mClass->mConstructArgs = &__Create;
__mClass->mGetStaticField = &hx::Class_obj::GetNoStaticField;
__mClass->mSetStaticField = &hx::Class_obj::SetNoStaticField;
__mClass->mMarkFunc = IOError_obj_sMarkStatics;
__mClass->mStatics = hx::Class_obj::dupFunctions(0 /* sStaticFields */);
__mClass->mMembers = hx::Class_obj::dupFunctions(0 /* sMemberFields */);
__mClass->mCanCast = hx::TCanCast< IOError_obj >;
#ifdef HXCPP_VISIT_ALLOCS
__mClass->mVisitFunc = IOError_obj_sVisitStatics;
#endif
#ifdef HXCPP_SCRIPTABLE
__mClass->mMemberStorageInfo = IOError_obj_sMemberStorageInfo;
#endif
#ifdef HXCPP_SCRIPTABLE
__mClass->mStaticStorageInfo = IOError_obj_sStaticStorageInfo;
#endif
hx::_hx_RegisterClass(__mClass->mName, __mClass);
}
} // end namespace openfl
} // end namespace errors
| [
"elsandkls@kidshideaway.net"
] | elsandkls@kidshideaway.net |
c966fa5d2efd0955f5fde5fae461dfbafd2af6b1 | 9c5a7750e380f9e882c8e2c0a379a7d2a933beae | /LDS/DesCrossLjbDlg.h | 2bda8e98b270b1dfa1f5de6153b8c5d87cadbacf | [] | no_license | presscad/LDS | 973e8752affd1147982a7dd48350db5c318ed1f3 | e443ded9cb2fe679734dc17af8638adcf50465d4 | refs/heads/master | 2021-02-15T20:30:26.467280 | 2020-02-28T06:13:53 | 2020-02-28T06:13:53 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,333 | h | #if !defined(AFX_DESCROSSLJBDLG_H__3BECFC26_D9B6_4349_B008_A7492FC0A4CF__INCLUDED_)
#define AFX_DESCROSSLJBDLG_H__3BECFC26_D9B6_4349_B008_A7492FC0A4CF__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// DesCrossLjbDlg.h : header file
//
/////////////////////////////////////////////////////////////////////////////
// CDesCrossLjbDlg dialog
class CDesCrossLjbDlg : public CDialog
{
// Construction
public:
CDesCrossLjbDlg(CWnd* pParent = NULL); // standard constructor
// Dialog Data
//{{AFX_DATA(CDesCrossLjbDlg)
enum { IDD = IDD_DES_CROSS_LJB_DLG };
int m_nThick;
int m_nVertexDist;
CString m_sPartSegI;
CString m_sPartNo;
int m_iProfileType;
int m_iMaterial;
//}}AFX_DATA
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CDesCrossLjbDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
// Generated message map functions
//{{AFX_MSG(CDesCrossLjbDlg)
virtual BOOL OnInitDialog();
afx_msg void OnChangePartNo();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_DESCROSSLJBDLG_H__3BECFC26_D9B6_4349_B008_A7492FC0A4CF__INCLUDED_)
| [
"wxc_sxy@163.com"
] | wxc_sxy@163.com |
dc4cba741572a883fa0c5adf65e23d99705e1e05 | bb5371b9a1574654760dbc2627f7fe542d3be1bd | /ppp/ppp_module.h | 7a6af10f98cc3dd945ca181568c037c100ec5ab6 | [
"BSD-3-Clause"
] | permissive | roxell/odp-example-sisu | 60bec41c27b118fe9988bcca7882af0f88e240d5 | a0896101fada5840aa49868c4aef0139ea9e3b5d | refs/heads/master | 2021-01-17T22:00:42.659199 | 2016-09-08T14:18:54 | 2016-09-08T14:34:28 | 67,710,707 | 0 | 0 | null | 2016-09-08T14:31:33 | 2016-09-08T14:31:33 | null | UTF-8 | C++ | false | false | 1,265 | h | /* Copyright 2015, ARM Limited or its affiliates. All rights reserved. */
//Packet Processing Pipeline - module definitions
#ifndef _PPP_MODULE_H
#define _PPP_MODULE_H
#include <stdint.h>
#include <stdlib.h>
#include <odp.h>
#include "stdatomic.h"
#include "ppp_graph.h"
class ppp_packet;
class ppp_graph;
union ppp_message;
class ppp_module
{
ppp_module *next;
protected:
ppp_graph *graph;
public:
const char * const name;
const char * const type;
atomic_uint32 num_discard_evt;
ppp_module(ppp_graph *_gr, const char *_name, const char *_type);
virtual ~ppp_module();
ppp_module(const ppp_module & _mod)://Copy constructor
name(NULL), type(NULL)
{
abort();
}
ppp_module &operator=(const ppp_module&)//Assignment operator
{
abort();
}
//Socket descriptor handler of module
virtual void sd_handler(int sd, int poll_events);
void register_sd(int sd, int poll_events);
void unregister_sd(int sd);
//The discard functions that are the default inputs for all outputs
void discard_pkt(ppp_packet *pkt);
void discard_pkt2(ppp_packet *pkt, uint32_t);
void discard_evt(odp_event_t evt, void *ctx);
friend class ppp_graph;
friend class ppp_if;
};
#endif //_PPP_MODULE_H
| [
"ola.liljedahl@arm.com"
] | ola.liljedahl@arm.com |
43255b9798c21dca7bd163c7d73a1f8222e009bd | c5a22b55781c5aa18cd8ddbbaabdf6e4f4bf3ed4 | /include/jadesoul/utils/str.hpp | bc6891d54ebf0b114d8e5cccd3363b92f5a8d9f0 | [] | no_license | jadesoul/jadesoulpp | fc575db15d37d2290835c9d924def5531f736657 | 7a6bd0b8a36951a5de5420028297a45b04d17951 | refs/heads/master | 2021-01-25T12:08:42.713083 | 2012-08-30T07:15:37 | 2012-08-30T07:15:37 | 5,610,275 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,422 | hpp | #ifndef STR_HPP_1324997558_33
#define STR_HPP_1324997558_33
/**
* File: str.hpp
* Description:
*
* Copyright (c) 2011 Jadesoul (Home Page: http://jadesoul.org)
* Licensed under the GNU General Public License:
* http://www.gnu.org/licenses/gpl.html
*
* Date: 2011-12-27 22:52:38.326000
* Written In: Peking University, beijing, China
*/
#include "includes.hpp"
#include "object.hpp"
#include "range.hpp"
class str {
public:
typedef std::vector<str> vecstr;
typedef std::string container;
typedef container::iterator iterator;
typedef container::const_iterator citerator;
typedef container::reverse_iterator riterator;
typedef container::const_reverse_iterator criterator;
private:
container s;
public:
inline iterator begin() { return s.begin(); }
inline iterator end() { return s.end(); }
inline riterator rbegin() { return s.rbegin(); }
inline riterator rend() { return s.rend(); }
inline citerator begin() const { return s.begin(); }
inline citerator end() const { return s.end(); }
inline criterator rbegin() const { return s.rbegin(); }
inline criterator rend() const { return s.rend(); }
//for size query
inline const uint size() const { return s.size(); }
inline const bool empty() const { return s.empty(); }
inline const bool equals(const str& r) const { return s==r.s; }
/**************************************************
constructors:
**************************************************/
inline str() {}
inline str(const char* cstr):s(cstr) {} //construction from c-style string
inline str(const string& cs):s(cs) {} //construction from std string
template<class Iterator>
inline str(Iterator begin, Iterator end):s(begin, end) {} //construction from two iterators
inline str(const char& c) { // construction from char
char buf[2];
buf[0]=c;
buf[1]=0;
s=buf;
}
inline str(const uchar& c) { // construction from uchar
char buf[2];
buf[0]=c;
buf[1]=0;
s=buf;
}
inline str(const short& n) { // construction from short
char buf[16];
sprintf(buf, "%d", n);
s=buf;
}
inline str(const ushort& n) { // construction from ushort
char buf[16];
sprintf(buf, "%d", n);
s=buf;
}
inline str(const int& n) { // construction from int
char buf[16];
sprintf(buf, "%d", n);
s=buf;
}
inline str(const uint& n) { // construction from uint
char buf[16];
sprintf(buf, "%u", n);
s=buf;
}
inline str(const long& n) { // construction from long
char buf[32];
sprintf(buf, "%ld", n);
s=buf;
}
str(const ulong& n) { // construction from ulong
char buf[32];
sprintf(buf, fmtstr_ulong, n);
s=buf;
}
inline str(const float& n) { // construction from float
char buf[32];
sprintf(buf, "%f", n);
s=buf;
}
inline str(const double& n) { // construction from double
char buf[32];
sprintf(buf, "%g", n);
s=buf;
}
inline str(const str& s):s(s.s) {} //copy construction
/**************************************************
bool expressions: == != > >= < <= !
**************************************************/
inline const bool operator==(const str& r) const { return s==r.s; }
inline const bool operator<(const str& r) const { return s<r.s; }
inline const bool operator>(const str& r) const { return s>r.s; }
inline const bool operator!=(const str& r) const { return s!=r.s; }
inline const bool operator<=(const str& r) const { return s<=r.s; }
inline const bool operator>=(const str& r) const { return s>=r.s; }
inline const bool operator!() const { return empty(); }
/**************************************************
tostr
output operator: <<
**************************************************/
inline friend ostream& operator <<(ostream& o, const str& s) {
// return o<<'"'<<s.s<<'"';
return o<<s.s;
}
inline const string tostr() const { return s; }
inline const char* tocstr() const { return s.c_str(); }
inline const string repr() const { return string("\"")+clone()
.replace("\\", "\\\\").replace("\t", "\\t")
.replace("\v", "\\v").replace("\r", "\\r")
.replace("\n", "\\n").tostr()+"\""; }
/**************************************************
assign
operator: =
**************************************************/
inline str& operator=(const str& r) {
return assign(r);
}
inline str& assign(const str& r) {
s=r.s;
return *this;
}
/**************************************************
operator: + += * *=
**************************************************/
inline str operator +(const str& r) { //for connection
return str(s+r.s);
}
inline str added(const str& r) { return (*this)+r; }
inline str operator +(const char* r) { //for connection
return clone()+=r;
}
inline str& operator +=(const str& r) {
s+=r.s;
return *this;
}
inline str& add(const str& r) { return (*this)+=r; }
inline str& operator +=(const string& r) {
s+=r;
return *this;
}
inline str& operator +=(const char* r) {
s+=r;
return *this;
}
inline str operator *(int n) { //for multiply
return repeated(n);
}
inline str& operator *=(int n) {
return repeat(n);
}
/**************************************************
operator: [](int)
operator: [](string)
at
**************************************************/
inline char& operator[](int i) { //for element visiting
if (i<0) i+=s.size();
return s[i];
}
inline const char& operator[](int i) const {
if (i<0) i+=s.size();
return s[i];
}
inline str operator [](const char* cstr) {
return str::slice(range(cstr));
}
inline char& at(int i) { //for element visiting, much more safe
uint len=s.size();
assert(len>0);
while(i<0) i+=len;
while(i>=static_cast<int>(len)) i-=len;
return s.at(i);
}
/**************************************************
slice: substr
operator: ()(pos)
operator: ()(start, stop, step)
**************************************************/
//for substr getter
inline str operator()(int pos) const {
uint l=size();
if (pos<0) pos+=l;
assert(pos>=0 AND pos<static_cast<int>(l));
return s.substr(pos);
}
//for substr
str operator()(int start, int stop, int step=1) const {
if (step==0) return "";
uint l=size();
if (start<0) start+=l;
assert(start>=0 AND start<static_cast<int>(l));
if (stop<0) stop+=l;
if (step>0) {
assert(stop>=0 AND stop<=static_cast<int>(l));
int sl=stop-start;
if (sl<=0) return "";
if (step==1) return s.substr(start, sl);
string ret;
ret.reserve(sl);
for (uint i=start; static_cast<int>(i)<stop; i+=step) ret.push_back(s[i]);
return ret;
} else {
assert(stop>=-1 AND stop<static_cast<int>(l));
int sl=start-stop;
if (sl<=0) return "";
if (step==-1) return string(s.rbegin()+start, s.rbegin()+(start+sl));
string ret;
ret.reserve(sl);
for (uint i=start; static_cast<int>(i)>stop; i+=step) ret.push_back(s[i]);
return ret;
}
}
//for slice
inline str slice(const range& r) {
// cout<<r<<endl;
return ::slice(s, r);
}
/*************************************************
S.split([sep [,results]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string. If results is given, it will get all the
result list of strings. If sep is not specified, any
whitespace string is a separator and empty strings are removed
from the result.
*************************************************/
template<class Container>
inline Container& split(const str& sep, Container& results) { //faster version
vector<string::iterator> o;
::split(s, sep, o);
for (uint i=0; i<o.size(); i+=2) results.insert(results.end(), typename Container::value_type(o[i], o[i+1]));
return results;
}
inline const vecstr split(const str& sep) { //slower version
vecstr vs;
vs.reserve(20);
return this->split(sep, vs);
}
vecstr split() {
vecstr vs;
vs.reserve(20);
//TODO
return striped().split(" ", vs);
}
/*************************************************
S.join(sequence) -> str
Return a string which is the concatenation of the strings in the
sequence. The separator between elements is S.
*************************************************/
template<class Container>
inline str join(const Container& con) const {
string ret;
ret.reserve(1024);
return ::join(s, con, ret);
}
/*************************************************
S.find(sub [,start [,end]]) -> int
Search from left to right.
Return the lowest index in S where substring sub is found,
such that sub is contained within s[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
*************************************************/
inline int find(const str& sub, int start=0, int end=0) const {
citerator a=(start<0?s.end():s.begin())+start, b=(end<=0?s.end():s.begin())+end;
if (a>=b) return -1;
citerator c=std::search(a, b, sub.begin(), sub.end());
return (c==b)?-1:c-a;
}
/*************************************************
S.rfind(sub [,start [,end]]) -> int
Search from right to left.
Return the highest index in S where substring sub is found,
such that sub is contained within s[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
*************************************************/
inline int rfind(const str& sub, int start=0, int end=0) const {
uint l=size();
if (start<0) start+=l;
if (end<=0) end+=l;
start=l-start;
end=l-end;
assert(start>0);
assert(end>=0);
criterator a=s.rbegin()+end, b=s.rbegin()+start;
if (a>=b) return -1;
criterator c=std::search(a, b, sub.rbegin(), sub.rend());
return (c==b)?-1:(b-c)-sub.size();
}
/*************************************************
S.clone() -> new str
Return a deep copy of string S, which is a clone
of S.
*************************************************/
inline str clone() const {
return s;
}
/*************************************************
S.replace(old, new[, count]) -> S
Return string S with all occurrences of substring old
replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
*************************************************/
str& replace(const str& old, const str& new_, uint count=-1) {
uint start=0, olen=old.size(), nlen=new_.size();
while(count==static_cast<uint>(-1) OR count-->static_cast<uint>(0)) {
start=s.find(old.s, start);
if (start==string::npos) break;
s.replace(start, olen, new_.s);
start+=nlen;
}
return *this;
}
/*************************************************
S.replaced(old, new[, count]) -> new str
Return a copy of string S with all occurrences
of substring old replaced by new. If the optional
argument count is given, only the first count
occurrences are replaced.
*************************************************/
inline str replaced(const str& old, const str& new_, uint count=-1) {
return clone().replace(old, new_, count);
}
/*************************************************
S.count(sub[, start[, end]]) -> uint
Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are interpreted
as in slice notation.
*************************************************/
inline uint count(const str& sub, int start=0, int end=0) {
return ::count((start<0?s.end():s.begin())+start, (end<=0?s.end():s.begin())+end, sub.begin(), sub.end());
}
/*************************************************
S.center(width[, fillchar]) -> string
Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
*************************************************/
inline str center(uint width, char fillchar) {
string ret(width, fillchar);
uint l=size();
if (width>=l) {
int r=(width-l)/2;
std::copy(s.begin(), s.end(), ret.begin()+r);
} else {
int r=(l-width)/2;
std::copy(s.begin()+r, s.begin()+(width+r), ret.begin());
}
return ret;
}
/*************************************************
S.startswith(prefix[, start[, end]]) -> bool
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
*************************************************/
bool startswith(const str& prefix, int start=0, int end=0) const {
return ::startswith((start<0?s.end():s.begin())+start, (end<=0?s.end():s.begin())+end, prefix.begin(), prefix.end());
}
/*************************************************
S.endswith(suffix[, start[, end]]) -> bool
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
*************************************************/
bool endswith(const str& prefix, int start=0, int end=0) const {
return ::endswith((start<0?s.end():s.begin())+start, (end<=0?s.end():s.begin())+end, prefix.begin(), prefix.end());
}
/*************************************************
S.expandtabs([tabsize]) -> string
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
*************************************************/
str expandtabs(uint tabsize=8) {
return replaced("\t", str(" ").repeated(tabsize));
}
/*************************************************
S.upper() -> S
S.uppered() -> new string
Return a copy of the string S converted to uppercase.
*************************************************/
str& upper() {
for (uint l=size(), i=0; i<l; ++i) {
char& c=s[i];
if (c>='a' AND c<='z') c+='A'-'a';
}
return *this;
}
inline str uppered() {
return clone().upper();
}
/*************************************************
S.lower() -> S
S.lowered() -> new string
Return a copy of the string S converted to lowercase.
*************************************************/
str& lower() {
for (uint l=size(), i=0; i<l; ++i) {
char& c=s[i];
if (c>='A' AND c<='Z') c+='a'-'A';
}
return *this;
}
inline str lowered() {
return clone().lower();
}
/*************************************************
S.swapcase() -> S
S.swapcased() -> new string
Return a copy of the string S with uppercase characters
converted to lowercase and vice versa.
*************************************************/
str& swapcase() {
for (uint l=size(), i=0; i<l; ++i) {
char& c=s[i];
if (c>='a' AND c<='z') c+='A'-'a';
else if (c>='A' AND c<='Z') c+='a'-'A';
}
return *this;
}
inline str swapcased() {
return clone().swapcase();
}
/*************************************************
S.reverse() -> S
S.reversed() -> new string
Return a copy of the string S with all chars
reversed.
*************************************************/
str& reverse() {
std::reverse(s.begin(), s.end());
return *this;
}
inline str reversed() {
return string(s.rbegin(), s.rend());
}
/*************************************************
S.repeat(n) -> S
S.repeated(n) -> new string
Return a copy of the string S with itself repeated
for n times. if n<0, the reversed S will be repeated.
*************************************************/
str& repeat(int n) {
str& me=*this;
uint l=size();
if (l==0) return me;
if (n==0) {
s.clear();
return me;
}
else if (n<0) {
me.reverse();
n=-n;
}
for (uint i=1; static_cast<int>(i)<n; ++i) s.append(s.begin(), s.begin()+l);
return me;
}
inline str repeated(int n) {
return clone().repeat(n);
}
/*************************************************
S.sort() -> S
S.sorted() -> new string
Return a copy of the string S with all chars
sorted.
*************************************************/
str& sort() {
std::sort(s.begin(), s.end());
return *this;
}
inline str sorted() {
return clone().sort();
}
/*************************************************
S.strip([chars]) -> S
S.lstrip([chars]) -> S
S.rstrip([chars]) -> S
S.striped([chars]) -> string
S.lstriped([chars]) -> string
S.rstriped([chars]) -> string
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given, remove characters in chars instead.
*************************************************/
inline str& strip(const str& chars=" \t\v\r\n\f") {
return rstrip(chars).lstrip(chars);
}
inline str& lstrip(const str& chars=" \t\v\r\n\f") {
s.erase(0, s.find_first_not_of(chars.s));
return *this;
}
inline str& rstrip(const str& chars=" \t\v\r\n\f") {
uint i=s.find_last_not_of(chars.s);
if (i==s.npos) return *this;
s.erase(i+1);
return *this;
}
inline str striped(const str& chars=" \t\v\r\n\f") {
return clone().strip(chars);
}
inline str lstriped(const str& chars=" \t\v\r\n\f") {
return clone().lstrip(chars);
}
inline str rstriped(const str& chars=" \t\v\r\n\f") {
return clone().rstrip(chars);
}
/**************************************************
tohash: x.tohash() <==> Return DWORD hash
**************************************************/
inline const uint tohash() const {
uint h=0, i=s.size();
while(i>0) h=107*h+s[--i];
return h;
}
};
typedef vector<str> vecstr;
#endif /* STR_HPP_1324997558_33 */
| [
"wslgb2006@gmail.com"
] | wslgb2006@gmail.com |
1d8671c64ba0edcb1e9e8988ef2e66984525375b | 32d79fd164614b06fb976721f980c068ee348abe | /tutorials/FollowMe2LearnQt/projects/01_01_HelloWorld/GeneratedFiles/qrc_HelloWorld.cpp | 7fbee842b2c73bea98b0c0ec70f4aa7016621bda | [
"MIT"
] | permissive | Ubpa/LearnQt | 3bf494237c0a2eedbee176c9096ac53843aff314 | e0d7f436dcc7c8f91f420d9265b411e5e783553d | refs/heads/master | 2020-04-18T03:16:41.082962 | 2019-01-26T08:05:46 | 2019-01-26T08:05:46 | 167,193,088 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,369 | cpp | /****************************************************************************
** Resource object code
**
** Created by: The Resource Compiler for Qt version 5.12.0
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#ifdef QT_NAMESPACE
# define QT_RCC_PREPEND_NAMESPACE(name) ::QT_NAMESPACE::name
# define QT_RCC_MANGLE_NAMESPACE0(x) x
# define QT_RCC_MANGLE_NAMESPACE1(a, b) a##_##b
# define QT_RCC_MANGLE_NAMESPACE2(a, b) QT_RCC_MANGLE_NAMESPACE1(a,b)
# define QT_RCC_MANGLE_NAMESPACE(name) QT_RCC_MANGLE_NAMESPACE2( \
QT_RCC_MANGLE_NAMESPACE0(name), QT_RCC_MANGLE_NAMESPACE0(QT_NAMESPACE))
#else
# define QT_RCC_PREPEND_NAMESPACE(name) name
# define QT_RCC_MANGLE_NAMESPACE(name) name
#endif
#ifdef QT_NAMESPACE
namespace QT_NAMESPACE {
#endif
#ifdef QT_NAMESPACE
}
#endif
int QT_RCC_MANGLE_NAMESPACE(qInitResources_HelloWorld)();
int QT_RCC_MANGLE_NAMESPACE(qInitResources_HelloWorld)()
{
return 1;
}
int QT_RCC_MANGLE_NAMESPACE(qCleanupResources_HelloWorld)();
int QT_RCC_MANGLE_NAMESPACE(qCleanupResources_HelloWorld)()
{
return 1;
}
namespace {
struct initializer {
initializer() { QT_RCC_MANGLE_NAMESPACE(qInitResources_HelloWorld)(); }
~initializer() { QT_RCC_MANGLE_NAMESPACE(qCleanupResources_HelloWorld)(); }
} dummy;
}
| [
"641614112@qq.com"
] | 641614112@qq.com |
acc6f82536234460f6da46250d9c57371a999363 | 8f7e1783102f8d7eb7766e53426b5668fa6a328a | /web_code/web/visualization_simulator.h | e8c0c7a3b29a333553447d2e56663312f4f513c7 | [] | no_license | parkpatt/bus-simulation | 362d928246af2060c4a53d4fca5348eab9f977c3 | 6ceefe2d2b25e3417fba78ed49c17ddccc9255d7 | refs/heads/main | 2023-03-27T20:23:52.984349 | 2021-03-17T17:20:44 | 2021-03-17T17:20:44 | 348,787,611 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,316 | h | /**
* @file visualization_simulator.h
*
* @copyright 2020 Parker Patterson
*
* @brief The header file for the visualization simulator
*/
#ifndef VISUALIZATION_SIMULATOR_H_
#define VISUALIZATION_SIMULATOR_H_
#include <vector>
#include <list>
#include <ctime>
#include "./web_interface.h"
#include "../../src/config_manager.h"
#include "../../src/bus_factory.h"
#include "../../src/iobserver.hh"
class Route;
class Bus;
class Stop;
class VisualizationSimulator {
public:
VisualizationSimulator(WebInterface*, ConfigManager*, BusFactory*);
~VisualizationSimulator();
void Start(const std::vector<int>&, const int&);
void Update();
void Pause();
void ClearListeners();
void AddListener(std::string* id, IObserver* observer);
void UpdateTime();
int GetTime() const {return current_time_;}
void PrintTime();
private:
WebInterface* webInterface_;
ConfigManager* configManager_;
BusFactory* busFactory_;
std::vector<int> busStartTimings_;
std::vector<int> timeSinceLastBus_;
int numTimeSteps_;
int simulationTimeElapsed_;
int current_time_;
std::vector<Route *> prototypeRoutes_;
std::vector<Bus *> busses_;
int busId = 1000;
bool paused = false;
};
#endif // VISUALIZATION_SIMULATOR_H_
| [
"noreply@github.com"
] | parkpatt.noreply@github.com |
5d083596e136279278c31d08ccc63ae160f55dbb | 57c478cc5536aa9a76f0829fc9ac903331774ff0 | /Source/NoTolerance/Item/Item.cpp | b86a12fbe9971ebdf6aae41cb7b068c14bccec67 | [] | no_license | cmduilio/NoTolerance | b3ef3cad6c44310d3af7b366c2499ae9816e5e24 | 99494079411e487e07837c3242ae5cec90dceb37 | refs/heads/master | 2023-07-02T07:53:11.043282 | 2021-08-08T21:48:30 | 2021-08-08T21:48:30 | 353,871,318 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 253 | cpp | // Fill out your copyright notice in the Description page of Project Settings.
#include "Item.h"
UItem::UItem()
{
DisplayName = FText::FromString("Name");
ActionText = FText::FromString("Action");
Description = FText::FromString("Description");
}
| [
"cmduilio@gmail.com"
] | cmduilio@gmail.com |
668ad63cda89fbf23ded34788318b1dcb8331254 | f212bb7e8e104e064eb5c22467e13e8164558c6c | /server_STM32/src/main.cpp | 83170ec27f02a3687886836d759224191a850dfd | [] | no_license | renelamo/Kcockpit | cb716f6bfcb0c24bccdec1b897fb391f137c9eb1 | 5998f1cbb8c46a2cc5c240b9e1374846e7e94cbb | refs/heads/master | 2022-10-22T06:55:19.344824 | 2021-04-05T14:36:35 | 2021-04-05T14:36:35 | 177,197,490 | 0 | 0 | null | 2022-10-04T23:59:16 | 2019-03-22T19:22:29 | C | UTF-8 | C++ | false | false | 1,483 | cpp | #include "Arduino.h"
#include "Comm.h"
#include "OutputsManager.h"
#include <InputsManager.h>
OutputsManager* omgr;
InputsManager* imgr;
HardwareTimer* timer;
void print_sizes(){
Serial.print("long ");Serial.println(sizeof(long));
Serial.print("long long ");Serial.println(sizeof(long long));
Serial.print("float "); Serial.println(sizeof(float));
Serial.print("double "); Serial.println(sizeof(double));
Serial.print("int ");Serial.println(sizeof(int));
Serial.print("short ");Serial.println(sizeof(short));
Serial.print("char ");Serial.println(sizeof(char));
Serial.print("byte "); Serial.println(sizeof(byte));
}
void timerISR(HardwareTimer*){
digitalToggle(LED_BUILTIN);
timer_flag = !timer_flag;
}
void setup(){
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_GREEN, HIGH);
Serial.setTimeout(100);
Serial.begin(115200, SERIAL_8N1);
omgr = new OutputsManager();
imgr = new InputsManager();
digitalWrite(LED_GREEN, LOW);
/*
timer = new HardwareTimer(TIM1);
timer->attachInterrupt(timerISR);
timer->setOverflow(2, HERTZ_FORMAT);
timer->resume();
//*/
omgr->setWaitMode(true);
int i = 0;
while(true){
//while (!Serial.available()){
omgr->wait(i++);
delay(100);
}
omgr->setWaitMode(false);
}
void loop(){
Comm::capt(omgr, imgr);
Serial.flush();//Pour pas surcharger la série, on s'assure qu'elle ait fini d'écrire avant de continuer
}
| [
"remi.lamiaux@telecom-sudparis.eu"
] | remi.lamiaux@telecom-sudparis.eu |
3fd7322236ca7fe3efbb26db8446d15d487b0d20 | e922b11f390758e0ca2f40174c0dbef11aef97bf | /Team Member Specfic/Aaron/Old BTS Material/dialog.h | fb3302e482304950b31688ef7adf7a1e5ca2ab31 | [] | no_license | AaronPatterson1/RaspiCameraSystem | aa15366e5171b8d6cfaa79515c89537276a39a66 | 2cfc75162ee2f66d1aeb714740a02bae1c11890c | refs/heads/master | 2021-08-31T22:49:38.285713 | 2017-04-10T20:38:10 | 2017-04-10T20:38:10 | 115,179,531 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 586 | h | #ifndef DIALOG_H
#define DIALOG_H
#include <QDialog>
#include <QTcpSocket>
namespace Ui {
class Dialog;
}
class Dialog : public QDialog
{
Q_OBJECT
public:
explicit Dialog(QWidget *parent = 0);
~Dialog();
QTcpSocket *m_pClientSocket;
private slots:
void displayError (QAbstractSocket::SocketError socketError);
private slots:
void on_pushButtonConnect_clicked();
void on_pushButtonSend_clicked();
void on_pushButtonLOG_clicked();
private:
Ui::Dialog *ui;
QString lines[100];
int numLines = 0;
bool isMoving;
};
#endif // DIALOG_H
| [
"blank"
] | blank |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.