row_id
int64 0
48.4k
| init_message
stringlengths 1
342k
| conversation_hash
stringlengths 32
32
| scores
dict |
|---|---|---|---|
8,835
|
Write description and some useful information about kotlin library Lincheck
|
ab9efa6da5f6d4aa046ece220c78c950
|
{
"intermediate": 0.6009358167648315,
"beginner": 0.16369496285915375,
"expert": 0.2353692352771759
}
|
8,836
|
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
import torch
from torch.utils.data import DataLoader, Dataset
from transformers import AutoTokenizer, AutoModelForSequenceClassification, AdamW
# define the model repo
model_name = "cointegrated/rubert-tiny"
# load the dataset
#df = pd.read_csv(‘dataset.csv’)
# preprocess the text data
tokenizer = AutoTokenizer.from_pretrained(model_name)
class CustomDataset(Dataset):
def __init__(self, texts, labels, tokenizer, max_length):
self.texts = texts
self.labels = labels
self.tokenizer = tokenizer
self.max_length = max_length
def __len__(self):
return len(self.texts)
def __getitem__(self, idx):
text = self.texts[idx]
label = self.labels[idx]
# tokenize the text using the tokenizer
encoding = self.tokenizer.encode_plus(
text,
add_special_tokens=True,
max_length=self.max_length,
pad_to_max_length=True,
return_tensors="pt"
)
return {
"input_ids": encoding["input_ids"].squeeze(),
"attention_mask": encoding["attention_mask"].squeeze(),
"labels": torch.tensor(label, dtype=torch.long).to(device)
}
device = "cuda" if torch.cuda.is_available() else "cpu"
# encode the labels
le = LabelEncoder()
train_data["label"] = le.fit_transform(train_data["category"])
# split the dataset into train and test set
X_train, X_test, y_train, y_test = train_test_split(train_data["text"], train_data["label"], test_size=0.2, random_state=42)
# create the dataloaders
train_dataset = CustomDataset(X_train.values, y_train.values, tokenizer, max_length=512)
test_dataset = CustomDataset(X_test.values, y_test.values, tokenizer, max_length=512)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)
# define the model and its optimizer
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=len(le.classes_)).to(device)
optimizer = AdamW(model.parameters(), lr=2e-5)
# training loop
num_epochs = 5
for epoch in range(num_epochs):
model.train()
for batch in train_loader:
inputs = {
"input_ids": batch["input_ids"].to(device),
"attention_mask": batch["attention_mask"].to(device),
"labels": batch["labels"].to(device)
}
#loss, _ = model(**inputs)
outputs = model(**inputs)
loss = outputs.loss
loss.backward()
optimizer.step()
optimizer.zero_grad()
model.eval()
with torch.no_grad():
total_correct = 0
total_count = 0
for batch in test_loader:
inputs = {
"input_ids": batch["input_ids"].to(device),
"attention_mask": batch["attention_mask"].to(device),
"labels": batch["labels"].to(device)
}
outputs = model(**inputs)
_, predicted = torch.max(outputs.logits, 1)
total_correct += (predicted == batch["labels"].to(device)).sum().item()
total_count += len(batch)
accuracy = total_correct / total_count
print(f"Epoch {epoch}, Accuracy: {accuracy}") Я обучил таким образом модель. Затем я пытаюсь ее запустить max_length = 512
# получить список токенизированных последовательностей списков
tokenized = [tokenizer.encode(text, add_special_tokens=True, max_length=max_length) for text in text_list]
# определить максимальную длину последовательности в списке токенов
max_len = max([len(seq) for seq in tokenized])
# заполнить последовательности до максимальной длины и преобразовать в формат, который можно передать в модель
input_ids = torch.tensor([t + [0]*(max_len-len(t)) for t in tokenized], dtype=torch.long)
attention_mask = torch.tensor([[float(i > 0) for i in ii] for ii in input_ids], dtype=torch.float)
# передать токенизированный вектор input_ids и маску внимания attention_mask для получения
# векторных представлений для каждого токена
with torch.no_grad():
outputs = model(input_ids=input_ids, attention_mask=attention_mask)
embeddings = outputs.last_hidden_state
# среднее каждого векторного представления по всем токенам в слове
# для получения векторного представления всей последовательности
mean_embeddings = torch.mean(embeddings, dim=1)
# преобразовать векторные представления в массив numpy и проверить размерность
mean_embeddings = mean_embeddings.numpy()
print(mean_embeddings.shape) RuntimeError: Expected all tensors to be on the same device, but found at least two devices, cuda:0 and cpu! (when checking argument for argument index in method wrapper_CUDA__index_select)
|
bab5b4d55e7882848abdbf370997ec58
|
{
"intermediate": 0.2785055935382843,
"beginner": 0.5566404461860657,
"expert": 0.16485394537448883
}
|
8,837
|
i want to click on this element with selenium I Agree
|
9329c89e5375d0189785de0379c91cb1
|
{
"intermediate": 0.40245792269706726,
"beginner": 0.26847684383392334,
"expert": 0.3290652334690094
}
|
8,838
|
--> 130 best_position, best_fitness = aco_fl(objective_function, num_ants, num_iterations, q0, alpha, beta, rho, lb, ub,global_model)
Cell In [32], line 76, in aco_fl(objective_function, num_ants, num_iterations, q0, alpha, beta, rho, lb, ub, global_model)
74 probabilities = np.nan_to_num(probabilities)
75 probabilities = normalize(probabilities)
---> 76 next_position = np.random.choice(len(lb), p=probabilities)
77 current_position[next_position] = 1
79 # Evaluate the fitness of the ant solution
File mtrand.pyx:920, in numpy.random.mtrand.RandomState.choice()
ValueError: probabilities contain NaN
|
e6d8514a7a9c36c079fec35fb6b31e09
|
{
"intermediate": 0.3471721112728119,
"beginner": 0.3543306589126587,
"expert": 0.29849720001220703
}
|
8,839
|
DROP TABLE IF EXISTS BOOKING;
DROP TABLE IF EXISTS [EVENT];
DROP TABLE IF EXISTS TOUR;
DROP TABLE IF EXISTS CLIENT;
GO
CREATE TABLE CLIENT(
CLIENTID INT,
SURNAME NVARCHAR(100) NOT NULL,
GIVENNAME NVARCHAR(100) NOT NULL,
GENDER NVARCHAR(1),
CONSTRAINT PK_CLIENT PRIMARY KEY(CLIENTID),
CONSTRAINT CHK_GENDER CHECK (GENDER IN('M','F','I'))
);
CREATE TABLE TOUR(
TOURNAME NVARCHAR(100),
[DESCRIPTION] NVARCHAR(500),
CONSTRAINT PK_TOUR PRIMARY KEY(TOURNAME)
);
CREATE TABLE EVENT(
TOURNAME NVARCHAR(100),
EVENTMONTH NVARCHAR(3),
EVENTDAY INT,
EVENTYEAR INT,
EVENTFEE MONEY NOT NULL,
CONSTRAINT PK_EVENT PRIMARY KEY(TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR),
CONSTRAINT FK_EVENT_TOUR FOREIGN KEY(TOURNAME) REFERENCES TOUR,
CONSTRAINT CHK_EVENT_EVENTMONTH CHECK(EVENTMONTH IN('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')),
CONSTRAINT CHK_EVENT_EVENTDAY CHECK(EVENTDAY >= 1 AND EVENTDAY <= 31),
CONSTRAINT CHK_EVENT_EVENTYEAR CHECK(LEN(EVENTYEAR) = 4),
CONSTRAINT CHK_EVENTFEE CHECK(EVENTFEE > 0)
);
CREATE TABLE BOOKING(
CLIENTID INT,
TOURNAME NVARCHAR(100),
EVENTMONTH NVARCHAR(3),
EVENTDAY INT,
EVENTYEAR INT,
PAYMENT MONEY,
DATEBOOKED DATE NOT NULL,
CONSTRAINT PK_BOOKING PRIMARY KEY(CLIENTID, TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR),
CONSTRAINT FK_BOOKING_EVENT FOREIGN KEY(TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR) REFERENCES [EVENT],
CONSTRAINT FK_BOOKING_CLIENT FOREIGN KEY(CLIENTID) REFERENCES CLIENT,
CONSTRAINT CHK_BOOKING_EVENTMONTH CHECK(EVENTMONTH IN('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')),
CONSTRAINT CHK_BOOKING_EVENTDAY CHECK(EVENTDAY >= 1 AND EVENTDAY <= 31),
CONSTRAINT CHK_BOOKING_EVENTYEAR CHECK(LEN(EVENTYEAR) = 4),
CONSTRAINT CHK_PAYMENT CHECK(PAYMENT> 0)
);
GO
INSERT INTO CLIENT(CLIENTID, SURNAME, GIVENNAME, GENDER)VALUES
(1, 'Price','Taylor','M'),
(2, 'Gamble','Ellyse','F'),
(3, 'Tan', 'Tilly', 'F'),
(4, 'Onna', 'Myowney', 'I');
INSERT INTO TOUR (TOURNAME, [DESCRIPTION]) VALUES
('North', 'Tour of wineries and outlets of the Bedigo and Castlemaine region'),
('South', 'Tour of wineries and outlets of Mornington Penisula'),
('West', 'Tour of wineries and outlets of the Geelong and Otways region');
INSERT INTO EVENT (TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR, EVENTFEE) VALUES
('North', 'Jan', 9, 2022, 200),
('North', 'Feb', 13, 2022, 225),
('South', 'Jan', 9, 2022, 200),
('South', 'Jan', 16, 2022, 200),
('West', 'Jan', 29, 2022, 225),
('West', 'Feb', 12, 2022, 225);
INSERT INTO BOOKING (CLIENTID, TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR, PAYMENT, DATEBOOKED) VALUES
(1, 'North', 'Jan', 9, 2022, 200, '2021/12/10'),
(2, 'North', 'Jan', 9, 2022, 200, '2022/01/03'),
(1, 'North', 'Feb', 13, 2022, 225, '2022/01/28'),
(2, 'North', 'Feb', 13, 2022, 125, '2022/01/14'),
(3, 'North', 'Feb', 13, 2022, 225, '2022/02/10'),
(1, 'South', 'Jan', 9, 2022, 200, '2021/12/10'),
(1, 'South', 'Jan', 16, 2022, 200, '2022/1/11'),
(2, 'South', 'Jan', 16, 2022, 200, '2021/12/18'),
(3, 'South', 'Jan', 16, 2022, 200, '2022/01/15'),
(2, 'West', 'Jan', 29, 2022, 225, '2022/01/17'),
(3, 'West', 'Jan', 29, 2022, 200, '2021/12/18');
Using the information above answer the following only in SQL code within a single line:
select the number of bookings made for each tourname by each gender of client for events with an eventmonth of Feb and which have a number of bookings < 2
Your result set should have column headers like this tourname, gender, num bookings
|
737a0c9d40706ed83f54db080a92c5bc
|
{
"intermediate": 0.3500862717628479,
"beginner": 0.40005964040756226,
"expert": 0.24985407292842865
}
|
8,840
|
can you write cs106b priority queue binary heap?
|
62b76fdb759dcb4f7888fcdc39ec7112
|
{
"intermediate": 0.34591707587242126,
"beginner": 0.17230162024497986,
"expert": 0.4817813038825989
}
|
8,841
|
I want you to act as a tech writer. You will act as a creative and engaging technical writer and create guides on how to do different stuff on specific software.
write a a post for "TypeScript Modules".
|
eb8da0045cd1dfcfd61989cec9a2ead3
|
{
"intermediate": 0.5241937041282654,
"beginner": 0.2708267569541931,
"expert": 0.2049795240163803
}
|
8,842
|
DROP TABLE IF EXISTS BOOKING;
DROP TABLE IF EXISTS [EVENT];
DROP TABLE IF EXISTS TOUR;
DROP TABLE IF EXISTS CLIENT;
GO
CREATE TABLE CLIENT(
CLIENTID INT,
SURNAME NVARCHAR(100) NOT NULL,
GIVENNAME NVARCHAR(100) NOT NULL,
GENDER NVARCHAR(1),
CONSTRAINT PK_CLIENT PRIMARY KEY(CLIENTID),
CONSTRAINT CHK_GENDER CHECK (GENDER IN('M','F','I'))
);
CREATE TABLE TOUR(
TOURNAME NVARCHAR(100),
[DESCRIPTION] NVARCHAR(500),
CONSTRAINT PK_TOUR PRIMARY KEY(TOURNAME)
);
CREATE TABLE EVENT(
TOURNAME NVARCHAR(100),
EVENTMONTH NVARCHAR(3),
EVENTDAY INT,
EVENTYEAR INT,
EVENTFEE MONEY NOT NULL,
CONSTRAINT PK_EVENT PRIMARY KEY(TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR),
CONSTRAINT FK_EVENT_TOUR FOREIGN KEY(TOURNAME) REFERENCES TOUR,
CONSTRAINT CHK_EVENT_EVENTMONTH CHECK(EVENTMONTH IN('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')),
CONSTRAINT CHK_EVENT_EVENTDAY CHECK(EVENTDAY >= 1 AND EVENTDAY <= 31),
CONSTRAINT CHK_EVENT_EVENTYEAR CHECK(LEN(EVENTYEAR) = 4),
CONSTRAINT CHK_EVENTFEE CHECK(EVENTFEE > 0)
);
CREATE TABLE BOOKING(
CLIENTID INT,
TOURNAME NVARCHAR(100),
EVENTMONTH NVARCHAR(3),
EVENTDAY INT,
EVENTYEAR INT,
PAYMENT MONEY,
DATEBOOKED DATE NOT NULL,
CONSTRAINT PK_BOOKING PRIMARY KEY(CLIENTID, TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR),
CONSTRAINT FK_BOOKING_EVENT FOREIGN KEY(TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR) REFERENCES [EVENT],
CONSTRAINT FK_BOOKING_CLIENT FOREIGN KEY(CLIENTID) REFERENCES CLIENT,
CONSTRAINT CHK_BOOKING_EVENTMONTH CHECK(EVENTMONTH IN('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')),
CONSTRAINT CHK_BOOKING_EVENTDAY CHECK(EVENTDAY >= 1 AND EVENTDAY <= 31),
CONSTRAINT CHK_BOOKING_EVENTYEAR CHECK(LEN(EVENTYEAR) = 4),
CONSTRAINT CHK_PAYMENT CHECK(PAYMENT> 0)
);
GO
INSERT INTO CLIENT(CLIENTID, SURNAME, GIVENNAME, GENDER)VALUES
(1, 'Price','Taylor','M'),
(2, 'Gamble','Ellyse','F'),
(3, 'Tan', 'Tilly', 'F'),
(4, 'Onna', 'Myowney', 'I');
INSERT INTO TOUR (TOURNAME, [DESCRIPTION]) VALUES
('North', 'Tour of wineries and outlets of the Bedigo and Castlemaine region'),
('South', 'Tour of wineries and outlets of Mornington Penisula'),
('West', 'Tour of wineries and outlets of the Geelong and Otways region');
INSERT INTO EVENT (TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR, EVENTFEE) VALUES
('North', 'Jan', 9, 2022, 200),
('North', 'Feb', 13, 2022, 225),
('South', 'Jan', 9, 2022, 200),
('South', 'Jan', 16, 2022, 200),
('West', 'Jan', 29, 2022, 225),
('West', 'Feb', 12, 2022, 225);
INSERT INTO BOOKING (CLIENTID, TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR, PAYMENT, DATEBOOKED) VALUES
(1, 'North', 'Jan', 9, 2022, 200, '2021/12/10'),
(2, 'North', 'Jan', 9, 2022, 200, '2022/01/03'),
(1, 'North', 'Feb', 13, 2022, 225, '2022/01/28'),
(2, 'North', 'Feb', 13, 2022, 125, '2022/01/14'),
(3, 'North', 'Feb', 13, 2022, 225, '2022/02/10'),
(1, 'South', 'Jan', 9, 2022, 200, '2021/12/10'),
(1, 'South', 'Jan', 16, 2022, 200, '2022/1/11'),
(2, 'South', 'Jan', 16, 2022, 200, '2021/12/18'),
(3, 'South', 'Jan', 16, 2022, 200, '2022/01/15'),
(2, 'West', 'Jan', 29, 2022, 225, '2022/01/17'),
(3, 'West', 'Jan', 29, 2022, 200, '2021/12/18');
Look at this sql code, how many bookings made for each tourname by each gender of client for events with an eventmonth of Feb and which have a number of bookings less than 2 ? answer this in written text not in code
|
3cbde3347b46ee936ca147b81d230453
|
{
"intermediate": 0.3500862717628479,
"beginner": 0.40005964040756226,
"expert": 0.24985407292842865
}
|
8,843
|
Use a pretrained deep learning model for object detection (ex: Yolo or MobileNet
SSD) to detect moving object in a video.
• Implement a tracking algorithm (ex: DeepSort, Opencv tracking algorithms) to track
multiple objects in a video.
• Use the object detection model and the tracking algorithm to formulate a video
summarization algorithm that only selects the frames with motion in them.
but dont use DeepSort & Motpy
|
dfb37740d5ae50e345277a11372cd415
|
{
"intermediate": 0.24328380823135376,
"beginner": 0.2578281760215759,
"expert": 0.4988880157470703
}
|
8,844
|
what does this line do in c?
|
ad87b12b84912bb618c62fecdb192126
|
{
"intermediate": 0.3417704999446869,
"beginner": 0.36927998065948486,
"expert": 0.28894951939582825
}
|
8,845
|
We need to spoof the amount of processors and cores on Vmware. Software is hardware recognized that i use and i changed the settings to more optimal ones. developer can not be reached ever again he died. so we need to be able to spoof the processors and cores on vmware. The vm is running windows 10. Since it is a vm i dont care if it might break it as i can revert to snapshot.
|
7ce9ee0b424cbb80c54102389aac825b
|
{
"intermediate": 0.3343910872936249,
"beginner": 0.3133220374584198,
"expert": 0.3522869348526001
}
|
8,846
|
Capture the area (Image 1 to Image 2) by matching the template
|
2fbebdb1b74147d62deaaaf98c628e3f
|
{
"intermediate": 0.33215436339378357,
"beginner": 0.29978734254837036,
"expert": 0.36805832386016846
}
|
8,847
|
What does the following Node-Red code do, and can it be optimized?
[{"id":"3ba422b0.9c410e","type":"subflow","name":"Artnet","info":"# Art-Net encoder/decoder\n\nThis sublow is a bi-directional Art-Net encoder/decoder.\n\n## Receiving\n\nConnect a `udp in` object set to port *6454* to the input of the subflow. \nThe Art-Net data will be output as `msg.payload` in Buffer form. \nThe universe is available as `msg.topic`.\n\n## Sending\n\nSend an `Array` or `Buffer` to the Art-Net subflow and connect the sublow's output to a `udp out` object set to port *6454*.\nThe universe must be set as `msg.topic`.","in":[{"x":180,"y":140,"wires":[{"id":"54870efc.1f38e8"}]}],"out":[{"x":440,"y":140,"wires":[{"id":"54870efc.1f38e8","port":0}]}]},{"id":"54870efc.1f38e8","type":"function","z":"3ba422b0.9c410e","name":"Artnet","func":"const HEADER_SIZE = 18;\nconst ID = \"Art-Net\\0\";\nconst ArtDmxOpCode = 0x5000;\nconst ProtVer = 14;\ncontext.sequence = context.sequence || 0;\nconst Physical = 0;\n\nvar header = new Buffer(HEADER_SIZE);\nheader.fill(0);\n\nheader.write(ID);\nheader.writeUInt16LE(ArtDmxOpCode, 8);\nheader.writeUInt16BE(ProtVer, 10);\nheader.writeUInt8(Physical, 13);\n\n// Parse incoming Art-Net packets\nif (msg.payload.slice(0, 8).toString() == ID) {\n var Opcode = msg.payload.readUInt16LE(8);\n if (Opcode == ArtDmxOpCode) {\n var Universe = msg.payload.readUInt16LE(14);\n var Length = msg.payload.readUInt16BE(16);\n msg.topic = Universe;\n msg.payload = msg.payload.slice(HEADER_SIZE, Length + HEADER_SIZE);\n node.send(msg);\n }\n// Format incoming buffer or array into Art-Net packet\n} else {\n context.sequence++;\n header.writeUInt8(context.sequence, 12);\n if (context.sequence >= 255)\n context.sequence = 0;\n \n var Universe = msg.topic;\n var Length = msg.payload.length;\n if (Array.isArray(msg.payload)) {\n msg.payload = new Buffer(msg.payload);\n }\n header.writeUInt16LE(Universe, 14);\n header.writeUInt16BE(Length, 16);\n \n msg.payload = Buffer.concat([header, msg.payload]);\n node.send(msg);\n}\n\n\n","outputs":1,"noerr":0,"x":310,"y":140,"wires":[[]]},{"id":"d53116db.4e6448","type":"udp in","z":"52b800eb.285ab8","name":"","iface":"","port":"6454","ipv":"udp4","multicast":"false","group":"","datatype":"buffer","x":140,"y":140,"wires":[["8ae18555.173a08"]]},{"id":"bf51a0e4.9141c8","type":"inject","z":"52b800eb.285ab8","name":"","topic":"1","payload":"[255,255,255,255,255]","payloadType":"json","repeat":"","crontab":"","once":false,"x":190,"y":280,"wires":[["60275d4c.9b60dc"]]},{"id":"ed7aa2c1.abe42","type":"debug","z":"52b800eb.285ab8","name":"","active":true,"console":"false","complete":"false","x":510,"y":140,"wires":[]},{"id":"87528ebd.ee762","type":"comment","z":"52b800eb.285ab8","name":"Receive","info":"","x":130,"y":100,"wires":[]},{"id":"8ae18555.173a08","type":"subflow:3ba422b0.9c410e","z":"52b800eb.285ab8","name":"","x":310,"y":140,"wires":[["ed7aa2c1.abe42"]]},{"id":"27a65618.ee047a","type":"udp out","z":"52b800eb.285ab8","name":"","addr":"localhost","iface":"","port":"6454","ipv":"udp4","outport":"","base64":false,"multicast":"false","x":660,"y":280,"wires":[]},{"id":"60275d4c.9b60dc","type":"subflow:3ba422b0.9c410e","z":"52b800eb.285ab8","name":"","x":430,"y":280,"wires":[["27a65618.ee047a"]]},{"id":"2c150c62.865b04","type":"comment","z":"52b800eb.285ab8","name":"Send","info":"","x":130,"y":240,"wires":[]},{"id":"d3233035.bedfe8","type":"comment","z":"52b800eb.285ab8","name":"Art-Net sending and receiving","info":"","x":200,"y":40,"wires":[]}]
|
04d6e576a8f361fc45a0c9255a62aeec
|
{
"intermediate": 0.27176329493522644,
"beginner": 0.2500671148300171,
"expert": 0.4781695306301117
}
|
8,848
|
DROP TABLE IF EXISTS BOOKING;
DROP TABLE IF EXISTS [EVENT];
DROP TABLE IF EXISTS TOUR;
DROP TABLE IF EXISTS CLIENT;
GO
CREATE TABLE CLIENT(
CLIENTID INT,
SURNAME NVARCHAR(100) NOT NULL,
GIVENNAME NVARCHAR(100) NOT NULL,
GENDER NVARCHAR(1),
CONSTRAINT PK_CLIENT PRIMARY KEY(CLIENTID),
CONSTRAINT CHK_GENDER CHECK (GENDER IN('M','F','I'))
);
CREATE TABLE TOUR(
TOURNAME NVARCHAR(100),
[DESCRIPTION] NVARCHAR(500),
CONSTRAINT PK_TOUR PRIMARY KEY(TOURNAME)
);
CREATE TABLE EVENT(
TOURNAME NVARCHAR(100),
EVENTMONTH NVARCHAR(3),
EVENTDAY INT,
EVENTYEAR INT,
EVENTFEE MONEY NOT NULL,
CONSTRAINT PK_EVENT PRIMARY KEY(TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR),
CONSTRAINT FK_EVENT_TOUR FOREIGN KEY(TOURNAME) REFERENCES TOUR,
CONSTRAINT CHK_EVENT_EVENTMONTH CHECK(EVENTMONTH IN('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')),
CONSTRAINT CHK_EVENT_EVENTDAY CHECK(EVENTDAY >= 1 AND EVENTDAY <= 31),
CONSTRAINT CHK_EVENT_EVENTYEAR CHECK(LEN(EVENTYEAR) = 4),
CONSTRAINT CHK_EVENTFEE CHECK(EVENTFEE > 0)
);
CREATE TABLE BOOKING(
CLIENTID INT,
TOURNAME NVARCHAR(100),
EVENTMONTH NVARCHAR(3),
EVENTDAY INT,
EVENTYEAR INT,
PAYMENT MONEY,
DATEBOOKED DATE NOT NULL,
CONSTRAINT PK_BOOKING PRIMARY KEY(CLIENTID, TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR),
CONSTRAINT FK_BOOKING_EVENT FOREIGN KEY(TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR) REFERENCES [EVENT],
CONSTRAINT FK_BOOKING_CLIENT FOREIGN KEY(CLIENTID) REFERENCES CLIENT,
CONSTRAINT CHK_BOOKING_EVENTMONTH CHECK(EVENTMONTH IN('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')),
CONSTRAINT CHK_BOOKING_EVENTDAY CHECK(EVENTDAY >= 1 AND EVENTDAY <= 31),
CONSTRAINT CHK_BOOKING_EVENTYEAR CHECK(LEN(EVENTYEAR) = 4),
CONSTRAINT CHK_PAYMENT CHECK(PAYMENT> 0)
);
GO
INSERT INTO CLIENT(CLIENTID, SURNAME, GIVENNAME, GENDER)VALUES
(1, 'Price','Taylor','M'),
(2, 'Gamble','Ellyse','F'),
(3, 'Tan', 'Tilly', 'F'),
(4, 'Onna', 'Myowney', 'I');
INSERT INTO TOUR (TOURNAME, [DESCRIPTION]) VALUES
('North', 'Tour of wineries and outlets of the Bedigo and Castlemaine region'),
('South', 'Tour of wineries and outlets of Mornington Penisula'),
('West', 'Tour of wineries and outlets of the Geelong and Otways region');
INSERT INTO EVENT (TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR, EVENTFEE) VALUES
('North', 'Jan', 9, 2022, 200),
('North', 'Feb', 13, 2022, 225),
('South', 'Jan', 9, 2022, 200),
('South', 'Jan', 16, 2022, 200),
('West', 'Jan', 29, 2022, 225),
('West', 'Feb', 12, 2022, 225);
INSERT INTO BOOKING (CLIENTID, TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR, PAYMENT, DATEBOOKED) VALUES
(1, 'North', 'Jan', 9, 2022, 200, '2021/12/10'),
(2, 'North', 'Jan', 9, 2022, 200, '2022/01/03'),
(1, 'North', 'Feb', 13, 2022, 225, '2022/01/28'),
(2, 'North', 'Feb', 13, 2022, 125, '2022/01/14'),
(3, 'North', 'Feb', 13, 2022, 225, '2022/02/10'),
(1, 'South', 'Jan', 9, 2022, 200, '2021/12/10'),
(1, 'South', 'Jan', 16, 2022, 200, '2022/1/11'),
(2, 'South', 'Jan', 16, 2022, 200, '2021/12/18'),
(3, 'South', 'Jan', 16, 2022, 200, '2022/01/15'),
(2, 'West', 'Jan', 29, 2022, 225, '2022/01/17'),
(3, 'West', 'Jan', 29, 2022, 200, '2021/12/18');
SELECT TOURNAME, GENDER, COUNT(*) as 'num bookings' FROM BOOKING
JOIN CLIENT ON BOOKING.CLIENTID = CLIENT.CLIENTID
GROUP BY TOURNAME, GENDER ORDER BY TOURNAME DESC, GENDER;
Using the information above answer the following only in SQL code within a single line:
Part 1:
Write a query that lists the clientid of all female clients.
Part 2:
Write a query that uses your query from part 1 as a sub query.
The query must list all the columns for bookings (booking table only) which were made by female clients.
This query must use the IN operator.
Your result set should have column headers like this
clientid, tourname, eventmonth, eventday, eventyear, payment, datebooked
|
9446e124ddd4187e514173801be01064
|
{
"intermediate": 0.3500862717628479,
"beginner": 0.40005964040756226,
"expert": 0.24985407292842865
}
|
8,849
|
How to summarize a video using Yolov5 and deepsort
|
9f34327b6515a8e105447958c461f9b2
|
{
"intermediate": 0.17481552064418793,
"beginner": 0.07233575731515884,
"expert": 0.7528486847877502
}
|
8,850
|
DROP TABLE IF EXISTS BOOKING;
DROP TABLE IF EXISTS [EVENT];
DROP TABLE IF EXISTS TOUR;
DROP TABLE IF EXISTS CLIENT;
GO
CREATE TABLE CLIENT(
CLIENTID INT,
SURNAME NVARCHAR(100) NOT NULL,
GIVENNAME NVARCHAR(100) NOT NULL,
GENDER NVARCHAR(1),
CONSTRAINT PK_CLIENT PRIMARY KEY(CLIENTID),
CONSTRAINT CHK_GENDER CHECK (GENDER IN('M','F','I'))
);
CREATE TABLE TOUR(
TOURNAME NVARCHAR(100),
[DESCRIPTION] NVARCHAR(500),
CONSTRAINT PK_TOUR PRIMARY KEY(TOURNAME)
);
CREATE TABLE EVENT(
TOURNAME NVARCHAR(100),
EVENTMONTH NVARCHAR(3),
EVENTDAY INT,
EVENTYEAR INT,
EVENTFEE MONEY NOT NULL,
CONSTRAINT PK_EVENT PRIMARY KEY(TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR),
CONSTRAINT FK_EVENT_TOUR FOREIGN KEY(TOURNAME) REFERENCES TOUR,
CONSTRAINT CHK_EVENT_EVENTMONTH CHECK(EVENTMONTH IN('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')),
CONSTRAINT CHK_EVENT_EVENTDAY CHECK(EVENTDAY >= 1 AND EVENTDAY <= 31),
CONSTRAINT CHK_EVENT_EVENTYEAR CHECK(LEN(EVENTYEAR) = 4),
CONSTRAINT CHK_EVENTFEE CHECK(EVENTFEE > 0)
);
CREATE TABLE BOOKING(
CLIENTID INT,
TOURNAME NVARCHAR(100),
EVENTMONTH NVARCHAR(3),
EVENTDAY INT,
EVENTYEAR INT,
PAYMENT MONEY,
DATEBOOKED DATE NOT NULL,
CONSTRAINT PK_BOOKING PRIMARY KEY(CLIENTID, TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR),
CONSTRAINT FK_BOOKING_EVENT FOREIGN KEY(TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR) REFERENCES [EVENT],
CONSTRAINT FK_BOOKING_CLIENT FOREIGN KEY(CLIENTID) REFERENCES CLIENT,
CONSTRAINT CHK_BOOKING_EVENTMONTH CHECK(EVENTMONTH IN('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')),
CONSTRAINT CHK_BOOKING_EVENTDAY CHECK(EVENTDAY >= 1 AND EVENTDAY <= 31),
CONSTRAINT CHK_BOOKING_EVENTYEAR CHECK(LEN(EVENTYEAR) = 4),
CONSTRAINT CHK_PAYMENT CHECK(PAYMENT> 0)
);
GO
INSERT INTO CLIENT(CLIENTID, SURNAME, GIVENNAME, GENDER)VALUES
(1, 'Price','Taylor','M'),
(2, 'Gamble','Ellyse','F'),
(3, 'Tan', 'Tilly', 'F'),
(4, 'Onna', 'Myowney', 'I');
INSERT INTO TOUR (TOURNAME, [DESCRIPTION]) VALUES
('North', 'Tour of wineries and outlets of the Bedigo and Castlemaine region'),
('South', 'Tour of wineries and outlets of Mornington Penisula'),
('West', 'Tour of wineries and outlets of the Geelong and Otways region');
INSERT INTO EVENT (TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR, EVENTFEE) VALUES
('North', 'Jan', 9, 2022, 200),
('North', 'Feb', 13, 2022, 225),
('South', 'Jan', 9, 2022, 200),
('South', 'Jan', 16, 2022, 200),
('West', 'Jan', 29, 2022, 225),
('West', 'Feb', 12, 2022, 225);
INSERT INTO BOOKING (CLIENTID, TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR, PAYMENT, DATEBOOKED) VALUES
(1, 'North', 'Jan', 9, 2022, 200, '2021/12/10'),
(2, 'North', 'Jan', 9, 2022, 200, '2022/01/03'),
(1, 'North', 'Feb', 13, 2022, 225, '2022/01/28'),
(2, 'North', 'Feb', 13, 2022, 125, '2022/01/14'),
(3, 'North', 'Feb', 13, 2022, 225, '2022/02/10'),
(1, 'South', 'Jan', 9, 2022, 200, '2021/12/10'),
(1, 'South', 'Jan', 16, 2022, 200, '2022/1/11'),
(2, 'South', 'Jan', 16, 2022, 200, '2021/12/18'),
(3, 'South', 'Jan', 16, 2022, 200, '2022/01/15'),
(2, 'West', 'Jan', 29, 2022, 225, '2022/01/17'),
(3, 'West', 'Jan', 29, 2022, 200, '2021/12/18');
SELECT TOURNAME, GENDER, COUNT(*) as 'num bookings' FROM BOOKING
JOIN CLIENT ON BOOKING.CLIENTID = CLIENT.CLIENTID
GROUP BY TOURNAME, GENDER ORDER BY TOURNAME DESC, GENDER;
Using the information above answer the following only in SQL code within a single line:
For each datebooked in the booking table list the following columns ( use the built in DATENAME and DATEPART functions )
datebooked (the datevalue as it appears in the booking table)
DayOfWeek (e.g. Monday)
DayOfMonth (e.g. 25)
MonthName (e.g. March)
MonthNum (e.g. 3)
Year (e.g. 2022)
Your result set should have column headers like this, and the result set should be formatted as shown below
column headers: datebooked|DayOfWeek|DayOfMonth|MonthName|MonthNum|Year
format (this is an example): 2022-01-28|Friday|28|January|1|2022
|
4c6dd5702b77a6d401967da3ca92cd0e
|
{
"intermediate": 0.3500862717628479,
"beginner": 0.40005964040756226,
"expert": 0.24985407292842865
}
|
8,851
|
---> 79 next_position = np.random.choice(len(lb), p=probabilities)
80 current_position[next_position] = 1
82 # Evaluate the fitness of the ant solution
File mtrand.pyx:920, in numpy.random.mtrand.RandomState.choice()
ValueError: probabilities contain NaN
|
8200cd12ef964c7d536a4ca0d39b4245
|
{
"intermediate": 0.311709463596344,
"beginner": 0.3614141047000885,
"expert": 0.3268764317035675
}
|
8,852
|
how do i convert python to javascript
|
64ed7031556d2f831e8872bf230e201c
|
{
"intermediate": 0.4234655797481537,
"beginner": 0.26287898421287537,
"expert": 0.31365546584129333
}
|
8,853
|
DROP TABLE IF EXISTS BOOKING;
DROP TABLE IF EXISTS [EVENT];
DROP TABLE IF EXISTS TOUR;
DROP TABLE IF EXISTS CLIENT;
GO
CREATE TABLE CLIENT(
CLIENTID INT,
SURNAME NVARCHAR(100) NOT NULL,
GIVENNAME NVARCHAR(100) NOT NULL,
GENDER NVARCHAR(1),
CONSTRAINT PK_CLIENT PRIMARY KEY(CLIENTID),
CONSTRAINT CHK_GENDER CHECK (GENDER IN('M','F','I'))
);
CREATE TABLE TOUR(
TOURNAME NVARCHAR(100),
[DESCRIPTION] NVARCHAR(500),
CONSTRAINT PK_TOUR PRIMARY KEY(TOURNAME)
);
CREATE TABLE EVENT(
TOURNAME NVARCHAR(100),
EVENTMONTH NVARCHAR(3),
EVENTDAY INT,
EVENTYEAR INT,
EVENTFEE MONEY NOT NULL,
CONSTRAINT PK_EVENT PRIMARY KEY(TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR),
CONSTRAINT FK_EVENT_TOUR FOREIGN KEY(TOURNAME) REFERENCES TOUR,
CONSTRAINT CHK_EVENT_EVENTMONTH CHECK(EVENTMONTH IN('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')),
CONSTRAINT CHK_EVENT_EVENTDAY CHECK(EVENTDAY >= 1 AND EVENTDAY <= 31),
CONSTRAINT CHK_EVENT_EVENTYEAR CHECK(LEN(EVENTYEAR) = 4),
CONSTRAINT CHK_EVENTFEE CHECK(EVENTFEE > 0)
);
CREATE TABLE BOOKING(
CLIENTID INT,
TOURNAME NVARCHAR(100),
EVENTMONTH NVARCHAR(3),
EVENTDAY INT,
EVENTYEAR INT,
PAYMENT MONEY,
DATEBOOKED DATE NOT NULL,
CONSTRAINT PK_BOOKING PRIMARY KEY(CLIENTID, TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR),
CONSTRAINT FK_BOOKING_EVENT FOREIGN KEY(TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR) REFERENCES [EVENT],
CONSTRAINT FK_BOOKING_CLIENT FOREIGN KEY(CLIENTID) REFERENCES CLIENT,
CONSTRAINT CHK_BOOKING_EVENTMONTH CHECK(EVENTMONTH IN('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')),
CONSTRAINT CHK_BOOKING_EVENTDAY CHECK(EVENTDAY >= 1 AND EVENTDAY <= 31),
CONSTRAINT CHK_BOOKING_EVENTYEAR CHECK(LEN(EVENTYEAR) = 4),
CONSTRAINT CHK_PAYMENT CHECK(PAYMENT> 0)
);
GO
INSERT INTO CLIENT(CLIENTID, SURNAME, GIVENNAME, GENDER)VALUES
(1, 'Price','Taylor','M'),
(2, 'Gamble','Ellyse','F'),
(3, 'Tan', 'Tilly', 'F'),
(4, 'Onna', 'Myowney', 'I');
INSERT INTO TOUR (TOURNAME, [DESCRIPTION]) VALUES
('North', 'Tour of wineries and outlets of the Bedigo and Castlemaine region'),
('South', 'Tour of wineries and outlets of Mornington Penisula'),
('West', 'Tour of wineries and outlets of the Geelong and Otways region');
INSERT INTO EVENT (TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR, EVENTFEE) VALUES
('North', 'Jan', 9, 2022, 200),
('North', 'Feb', 13, 2022, 225),
('South', 'Jan', 9, 2022, 200),
('South', 'Jan', 16, 2022, 200),
('West', 'Jan', 29, 2022, 225),
('West', 'Feb', 12, 2022, 225);
INSERT INTO BOOKING (CLIENTID, TOURNAME, EVENTMONTH, EVENTDAY, EVENTYEAR, PAYMENT, DATEBOOKED) VALUES
(1, 'North', 'Jan', 9, 2022, 200, '2021/12/10'),
(2, 'North', 'Jan', 9, 2022, 200, '2022/01/03'),
(1, 'North', 'Feb', 13, 2022, 225, '2022/01/28'),
(2, 'North', 'Feb', 13, 2022, 125, '2022/01/14'),
(3, 'North', 'Feb', 13, 2022, 225, '2022/02/10'),
(1, 'South', 'Jan', 9, 2022, 200, '2021/12/10'),
(1, 'South', 'Jan', 16, 2022, 200, '2022/1/11'),
(2, 'South', 'Jan', 16, 2022, 200, '2021/12/18'),
(3, 'South', 'Jan', 16, 2022, 200, '2022/01/15'),
(2, 'West', 'Jan', 29, 2022, 225, '2022/01/17'),
(3, 'West', 'Jan', 29, 2022, 200, '2021/12/18');
using the information above answer the following SQL related question, answer only in sql code
Part 1:
Write a query that lists the clientid of all female clients.
Part 2:
Write a query that uses your query from part 1 as a sub query.
The query must list all the columns for bookings (booking table only) which were made by female clients.
This query must use the IN operator.
Your result set should have column headers like this clientid, tourname, eventmonth, eventday, eventyear, payment, datebooked
|
64bdadd26feb3b1847b17d1b0d34884a
|
{
"intermediate": 0.3500862717628479,
"beginner": 0.40005964040756226,
"expert": 0.24985407292842865
}
|
8,854
|
import torch
import torch.nn as nn
from torchtext.datasets import WikiText2
from torchtext.data.functional import to_map_style_dataset
from torchtext.data.utils import get_tokenizer
from torchtext.vocab import build_vocab_from_iterator
from torch.utils.data import DataLoader
# 1. Define the model
class TransformerModel(nn.Module):
def init(self, vocab_size, d_model, nhead, num_layers, dropout=0.1):
super(TransformerModel, self).init()
self.embedding = nn.Embedding(vocab_size, d_model)
self.transformer = nn.Transformer(d_model, nhead, num_layers, dropout=dropout)
self.fc = nn.Linear(d_model, vocab_size)
def forward(self, src, tgt):
src = self.embedding(src)
tgt = self.embedding(tgt)
x = self.transformer(src, tgt)
x = self.fc(x)
return x
# 2. Preparar datos
train_data_raw, valid_data_raw, _ = WikiText2(split=('train', 'valid', 'test'))
train_data_raw = to_map_style_dataset(train_data_raw)
valid_data_raw = to_map_style_dataset(valid_data_raw)
tokenizer = get_tokenizer("spacy", "en_core_web_sm")
# Agregar tokens especiales (UNK y PAD) al vocabulario
specials = ['<unk>','<pad>']
vocab = build_vocab_from_iterator((tokenizer(y) for y in train_data_raw), specials=specials)
vocab.set_default_index(vocab['<unk>'])
vocab_size = len(vocab)
d_model = 512 # Reduced to 512
nhead = 8
num_layers = 4 # Reduced to 4
num_epochs = 50 # Increased to 50
learning_rate = 5e-4 # Reduced to 5e-4
optimizer_choice = 'Adam'
batch_size = 128 # Increased to 128
max_seq_len = 100 # Increased to 100
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
train_batches = create_batches(train_data_raw, batch_size, max_seq_len=max_seq_len)
valid_batches = create_batches(valid_data_raw, batch_size, max_seq_len=max_seq_len)
train_loader = DataLoader(train_batches, batch_size=None, collate_fn=collate_fn)
valid_loader = DataLoader(valid_batches, batch_size=None, collate_fn=collate_fn)
model = TransformerModel(vocab_size=vocab_size, d_model=d_model, nhead=nhead, num_layers=num_layers, dropout=0.1).to(device)
loss_function = nn.CrossEntropyLoss()
# Use different optimizers
if optimizer_choice == "Adam":
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
elif optimizer_choice == "RMSprop":
optimizer = torch.optim.RMSprop(model.parameters(), lr=learning_rate)
elif optimizer_choice == "Adagrad":
optimizer = torch.optim.Adagrad(model.parameters(), lr=learning_rate)
else:
raise ValueError("Invalid optimizer choice")
def train(model, epoch):
model.train()
train_loss = 0
for i, (source, target) in enumerate(train_loader):
source = source.to(device)
target = target.to(device)
optimizer.zero_grad()
output = model(source, target[:-1])
loss = loss_function(output.reshape(-1, vocab_size), target[1:].reshape(-1))
loss.backward()
optimizer.step()
train_loss += loss.item()
if i % 1000 == 0:
print(f'Epoch: {epoch + 1},\tLoss: {loss.item()}')
return train_loss / len(train_loader)
for epoch in range(num_epochs):
start_time = time.time()
train_loss = train(model, epoch)
end_time = time.time()
elapsed_time = end_time - start_time
print(f"Epoch: {epoch + 1},\tAverage Loss: {train_loss},\tTime taken: {elapsed_time} seconds")
# 4. Evaluar el modelo en el conjunto de validación
def evaluate(model, valid_loader):
model.eval()
valid_loss = 0
with torch.no_grad():
for source, target in valid_loader:
source = source.to(device)
target = target.to(device)
output = model(source, target[:-1])
loss = loss_function(output.reshape(-1, vocab_size), target[1:].reshape(-1))
valid_loss += loss.item()
return valid_loss / len(valid_loader)
# 5. Entrenar y evaluar el modelo en cada época
for epoch in range(num_epochs):
start_time = time.time()
train_loss = train(model, epoch)
valid_loss = evaluate(model, valid_loader)
end_time = time.time()
elapsed_time = end_time - start_time
print(f"Epoch: {epoch + 1},\tAverage Train Loss: {train_loss},\tAverage Valid Loss: {valid_loss},\tTime taken: {elapsed_time} seconds")
# 6. Guardar el modelo entrenado
torch.save(model.state_dict(), "trained_model.pth")
# 7. Cargar el modelo
def load_model(path, device):
loaded_model = TransformerModel(vocab_size=vocab_size, d_model=d_model, nhead=nhead, num_layers=num_layers).to(device)
loaded_model.load_state_dict(torch.load(path))
loaded_model.eval()
return loaded_model
loaded_model = load_model("trained_model.pth", device)
# 8. Predecir texto
def decode_output(output):
probabilities = torch.softmax(output, dim=2)
predicted_indices = torch.argmax(probabilities, dim=2)
return " ".join(vocab.lookup_tokens(predicted_indices.cpu().numpy().squeeze().tolist()))
def predict_next_token(input_text, model):
tokens = tokenize_data(input_text)
source, target = generate_pairs(tokens, shift=1)
source = torch.tensor(source, dtype=torch.long).unsqueeze(1).to(device)
target = torch.tensor(target, dtype=torch.long).unsqueeze(1).to(device)
with torch.no_grad():
output = model(source, target[:-1])
return decode_output(output)
input_text = "My favorite color is"
predicted_output = predict_next_token(input_text, loaded_model)
print(f"Predicted output: {predicted_output}")
|
62a43cb2760d08a2febbdf9f88d81643
|
{
"intermediate": 0.2510882616043091,
"beginner": 0.4443551301956177,
"expert": 0.30455663800239563
}
|
8,855
|
I’m building a video game engine using C++ as the coding language and Vulkan for graphics. I am trying to set up a generic renderer using Vulkan that is flexible and will render objects based on a vector that is supplied to it. The renderer will also handle the creation of the window using GLFW and use GLM for all relevant math calls. I am using the ASSIMP library to load 3d models and animations.
Here is a portion of the code:
Renderer.h:
#pragma once
#include <vulkan/vulkan.h>
#include "Window.h"
#include <vector>
#include <stdexcept>
#include <set>
#include <optional>
#include <iostream>
#include "Pipeline.h"
#include "Material.h"
#include "Mesh.h"
struct QueueFamilyIndices
{
std::optional<uint32_t> graphicsFamily;
std::optional<uint32_t> presentFamily;
bool IsComplete()
{
return graphicsFamily.has_value() && presentFamily.has_value();
}
};
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities;
std::vector<VkSurfaceFormatKHR> formats;
std::vector<VkPresentModeKHR> presentModes;
};
class Renderer
{
public:
Renderer();
~Renderer();
void Initialize(GLFWwindow* window);
void Shutdown();
void BeginFrame();
void EndFrame();
VkDescriptorSetLayout CreateDescriptorSetLayout();
VkDescriptorPool CreateDescriptorPool(uint32_t maxSets);
VkDevice* GetDevice();
VkPhysicalDevice* GetPhysicalDevice();
VkCommandPool* GetCommandPool();
VkQueue* GetGraphicsQueue();
VkCommandBuffer* GetCurrentCommandBuffer();
std::shared_ptr<Pipeline> GetPipeline();
void CreateGraphicsPipeline(Mesh* mesh, Material* material);
private:
bool shutdownInProgress;
uint32_t currentCmdBufferIndex = 0;
std::vector<VkImage> swapChainImages;
std::vector<VkImageView> swapChainImageViews;
VkExtent2D swapChainExtent;
VkRenderPass renderPass;
uint32_t imageIndex;
std::shared_ptr<Pipeline> pipeline;
VkFormat swapChainImageFormat;
std::vector<VkCommandBuffer> commandBuffers;
void CreateImageViews();
void CleanupImageViews();
void CreateRenderPass();
void CleanupRenderPass();
void CreateSurface();
void DestroySurface();
void CreateInstance();
void CleanupInstance();
void ChoosePhysicalDevice();
void CreateDevice();
void CleanupDevice();
void CreateSwapchain();
void CleanupSwapchain();
void CreateCommandPool();
void CleanupCommandPool();
void CreateFramebuffers();
void CleanupFramebuffers();
void CreateCommandBuffers();
void CleanupCommandBuffers();
GLFWwindow* window;
VkInstance instance = VK_NULL_HANDLE;
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
VkDevice device = VK_NULL_HANDLE;
VkSurfaceKHR surface;
VkSwapchainKHR swapchain;
VkCommandPool commandPool;
VkCommandBuffer currentCommandBuffer;
std::vector<VkFramebuffer> framebuffers;
// Additional Vulkan objects needed for rendering…
const uint32_t kMaxFramesInFlight = 2;
std::vector<VkSemaphore> imageAvailableSemaphores;
std::vector<VkSemaphore> renderFinishedSemaphores;
std::vector<VkFence> inFlightFences;
size_t currentFrame;
VkQueue graphicsQueue;
VkQueue presentQueue;
void CreateSyncObjects();
void CleanupSyncObjects();
SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface);
VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats);
VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes);
VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window);
std::vector<const char*> deviceExtensions = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME
};
std::vector<const char*> CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice);
QueueFamilyIndices GetQueueFamilyIndices(VkPhysicalDevice physicalDevice);
};
Renderer.cpp:
#include "Renderer.h"
Renderer::Renderer() : currentFrame(0), shutdownInProgress(false)
{
}
Renderer::~Renderer()
{
Shutdown();
}
void Renderer::Initialize(GLFWwindow* window)
{
this->window = window;
CreateInstance();
CreateSurface();
ChoosePhysicalDevice();
CreateDevice();
CreateSwapchain();
CreateRenderPass();
CreateCommandPool();
CreateFramebuffers();
CreateSyncObjects();
}
void Renderer::Shutdown()
{
if (shutdownInProgress) {
return;
}
shutdownInProgress = true;
if (device != VK_NULL_HANDLE) {
vkDeviceWaitIdle(device);
}
CleanupFramebuffers();
CleanupRenderPass();
CleanupSyncObjects();
CleanupCommandBuffers();
CleanupCommandPool();
CleanupImageViews();
CleanupSwapchain();
if (device != VK_NULL_HANDLE) {
CleanupDevice();
}
DestroySurface();
CleanupInstance();
shutdownInProgress = false;
}
void Renderer::BeginFrame()
{
// Wait for any previous work on this swapchain image to complete
vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
vkResetFences(device, 1, &inFlightFences[currentFrame]);
// Acquire an image from the swapchain, then begin recording commands for the current frame.
VkResult acquireResult = vkAcquireNextImageKHR(device, swapchain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
if (acquireResult != VK_SUCCESS && acquireResult != VK_SUBOPTIMAL_KHR) {
throw std::runtime_error("Failed to acquire next swapchain image.");
}
VkCommandBufferBeginInfo beginInfo{};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
//currentCommandBuffer = commandBuffers[currentFrame];
currentCmdBufferIndex = (currentCmdBufferIndex + 1) % 2;
currentCommandBuffer = commandBuffers[currentFrame * 2 + currentCmdBufferIndex];
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
VkRenderPassBeginInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
renderPassInfo.renderPass = renderPass;
renderPassInfo.framebuffer = framebuffers[imageIndex];
renderPassInfo.renderArea.offset = { 0, 0 };
renderPassInfo.renderArea.extent = swapChainExtent;
// Set the clear color to black
VkClearValue clearColor = { 0.0f, 0.0f, 0.0f, 1.0f };
renderPassInfo.clearValueCount = 1;
renderPassInfo.pClearValues = &clearColor;
vkCmdBeginRenderPass(currentCommandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
}
void Renderer::EndFrame()
{
vkCmdEndRenderPass(currentCommandBuffer);
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &imageAvailableSemaphores[currentFrame];
submitInfo.pWaitDstStageMask = waitStages;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = ¤tCommandBuffer;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &renderFinishedSemaphores[currentFrame];
vkEndCommandBuffer(currentCommandBuffer);
vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]);
VkPresentInfoKHR presentInfo{};
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.waitSemaphoreCount = 1;
presentInfo.pWaitSemaphores = &renderFinishedSemaphores[currentFrame];
VkSwapchainKHR swapChains[] = { swapchain };
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = swapChains;
presentInfo.pImageIndices = &imageIndex;
VkResult queuePresentResult = vkQueuePresentKHR(presentQueue, &presentInfo);
if (queuePresentResult == VK_ERROR_OUT_OF_DATE_KHR || queuePresentResult == VK_SUBOPTIMAL_KHR) {
// Handle swapchain recreation if needed, e.g., due to resizing the window or other swapchain properties changes
}
else if (queuePresentResult != VK_SUCCESS) {
throw std::runtime_error("Failed to present the swapchain image.");
}
currentFrame = (currentFrame + 1) % kMaxFramesInFlight;
}
void Renderer::CreateSurface()
{
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a window surface.");
}
}
void Renderer::DestroySurface()
{
vkDestroySurfaceKHR(instance, surface, nullptr);
}
void Renderer::CreateInstance()
{
// Set up the application info
VkApplicationInfo appInfo{};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = "Game Engine";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "Game Engine";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_2;
// Set up the instance create info
VkInstanceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;
// Set up the required extensions
uint32_t glfwExtensionCount = 0;
const char** glfwExtensions;
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
createInfo.enabledExtensionCount = glfwExtensionCount;
createInfo.ppEnabledExtensionNames = glfwExtensions;
createInfo.enabledLayerCount = 0;
// Create the Vulkan instance
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create the Vulkan instance.");
}
}
void Renderer::CleanupInstance()
{
// Destroy the Vulkan instance
vkDestroyInstance(instance, nullptr);
}
void Renderer::ChoosePhysicalDevice()
{
// Enumerate the available physical devices and choose one that supports required features
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
if (deviceCount == 0)
{
throw std::runtime_error("Failed to find a GPU with Vulkan support.");
}
std::vector<VkPhysicalDevice> allDevices(deviceCount);
vkEnumeratePhysicalDevices(instance, &deviceCount, allDevices.data());
for (const auto& testDevice : allDevices)
{
if (glfwGetPhysicalDevicePresentationSupport(instance, testDevice, 0) &&
CheckPhysicalDeviceExtensionSupport(testDevice).empty() &&
GetQueueFamilyIndices(testDevice).IsComplete())
{
physicalDevice = testDevice;
break;
}
}
if (physicalDevice == VK_NULL_HANDLE)
{
throw std::runtime_error("Failed to find a suitable GPU.");
}
}
void Renderer::CreateDevice()
{
// Get the GPU’s queue family indices
const QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
// Set up the device queue create info
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
std::set<uint32_t> uniqueQueueFamilyIndices = { indices.graphicsFamily.value(),indices.presentFamily.value() };
float queuePriority = 1.0f;
for (uint32_t queueFamilyIndex : uniqueQueueFamilyIndices)
{
VkDeviceQueueCreateInfo queueCreateInfo{};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = queueFamilyIndex;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = &queuePriority;
queueCreateInfos.push_back(queueCreateInfo);
}
// Set up the physical device features
VkPhysicalDeviceFeatures deviceFeatures{};
// Set up the device create info
VkDeviceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
createInfo.pQueueCreateInfos = queueCreateInfos.data();
createInfo.pEnabledFeatures = &deviceFeatures;
createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
createInfo.ppEnabledExtensionNames = deviceExtensions.data();
// Create the logical device
if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a logical device.");
}
// Retrieve the graphics queue and the present queue
vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
}
void Renderer::CleanupDevice()
{
// Destroy the logical device
vkDestroyDevice(device, nullptr);
}
void Renderer::CreateSwapchain()
{
// Get swapchain support details
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice,surface);
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
swapChainImageFormat = surfaceFormat.format; // Initialize the swapChainImageFormat
VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities,window);
uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount)
{
imageCount = swapChainSupport.capabilities.maxImageCount;
}
// Create the swapchain
// …
VkSwapchainCreateInfoKHR createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = surface;
createInfo.minImageCount = imageCount;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() };
if (indices.graphicsFamily != indices.presentFamily) {
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
}
else {
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
}
createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapchain) != VK_SUCCESS) {
throw std::runtime_error("failed to create swap chain!");
}
// Retrieve swapchain images (color buffers)
// …
// Retrieve swapchain images
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, nullptr);
swapChainImages.resize(imageCount);
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, swapChainImages.data());
// Create image views for swapchain images
CreateImageViews();
}
void Renderer::CleanupSwapchain()
{
// Clean up Vulkan swapchain
if (swapchain != VK_NULL_HANDLE)
{
vkDestroySwapchainKHR(device, swapchain, nullptr);
swapchain = VK_NULL_HANDLE;
}
}
void Renderer::CreateImageViews()
{
swapChainImageViews.resize(swapChainImages.size());
for (size_t i = 0; i < swapChainImages.size(); ++i)
{
VkImageViewCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
createInfo.image = swapChainImages[i];
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
createInfo.format = swapChainImageFormat;
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
createInfo.subresourceRange.baseMipLevel = 0;
createInfo.subresourceRange.levelCount = 1;
createInfo.subresourceRange.baseArrayLayer = 0;
createInfo.subresourceRange.layerCount = 1;
createInfo.flags = 0;
if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create an image view.");
}
}
}
void Renderer::CleanupImageViews()
{
for (auto imageView : swapChainImageViews)
{
vkDestroyImageView(device, imageView, nullptr);
}
swapChainImageViews.clear();
}
void Renderer::CreateRenderPass()
{
VkAttachmentDescription colorAttachment{};
colorAttachment.format = swapChainImageFormat;
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
VkAttachmentReference colorAttachmentRef{};
colorAttachmentRef.attachment = 0;
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass{};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &colorAttachmentRef;
VkRenderPassCreateInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassInfo.attachmentCount = 1;
renderPassInfo.pAttachments = &colorAttachment;
renderPassInfo.subpassCount = 1;
renderPassInfo.pSubpasses = &subpass;
VkSubpassDependency dependency{};
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
dependency.dstSubpass = 0;
dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.srcAccessMask = 0;
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
renderPassInfo.dependencyCount = 1;
renderPassInfo.pDependencies = &dependency;
if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create render pass.");
}
}
void Renderer::CleanupRenderPass()
{
vkDestroyRenderPass(device, renderPass, nullptr);
}
void Renderer::CreateCommandPool()
{
// Find a queue family index that supports graphics operations
QueueFamilyIndices queueFamilyIndices = GetQueueFamilyIndices(physicalDevice);
// Create a command pool for the queue family
VkCommandPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
poolInfo.flags = 0;
if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create command pool.");
}
CreateCommandBuffers(); // Create command buffers after creating the command pool
}
void Renderer::CleanupCommandPool()
{
// Clean up Vulkan command pool
CleanupCommandBuffers(); // Add this line to clean up command buffers before destroying the command pool
vkDestroyCommandPool(device, commandPool, nullptr);
}
void Renderer::CreateCommandBuffers()
{
//commandBuffers.resize(kMaxFramesInFlight);
commandBuffers.resize(kMaxFramesInFlight * 2);
VkCommandBufferAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.commandPool = commandPool;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandBufferCount = static_cast<uint32_t>(commandBuffers.size());
if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS)
{
throw std::runtime_error("Failed to allocate command buffers.");
}
// Set the initial value of the currentCommandBuffer
currentCommandBuffer = commandBuffers[currentFrame];
}
void Renderer::CleanupCommandBuffers()
{
vkFreeCommandBuffers(device, commandPool, static_cast<uint32_t>(commandBuffers.size()), commandBuffers.data());
}
void Renderer::CreateFramebuffers()
{
// Check if the framebuffers vector is not empty, and call CleanupFramebuffers()
if (!framebuffers.empty()) {
CleanupFramebuffers();
}
// Create Vulkan framebuffers for swapchain images
framebuffers.resize(swapChainImageViews.size());
for (size_t i = 0; i < swapChainImageViews.size(); ++i)
{
VkImageView attachments[] = { swapChainImageViews[i] };
VkFramebufferCreateInfo framebufferInfo{};
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebufferInfo.renderPass = renderPass;
framebufferInfo.attachmentCount = 1;
framebufferInfo.pAttachments = attachments;
framebufferInfo.width = swapChainExtent.width;
framebufferInfo.height = swapChainExtent.height;
framebufferInfo.layers = 1;
if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &framebuffers[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create framebuffer.");
}
}
}
void Renderer::CleanupFramebuffers()
{
for (auto framebuffer : framebuffers)
{
if (framebuffer != VK_NULL_HANDLE)
{
vkDestroyFramebuffer(device, framebuffer, nullptr);
framebuffer = VK_NULL_HANDLE;
}
}
framebuffers.clear(); // Make sure to clear the framebuffers vector after destroying each framebuffer
}
void Renderer::CreateSyncObjects()
{
imageAvailableSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
renderFinishedSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
inFlightFences.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
VkSemaphoreCreateInfo semaphoreInfo{};
semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
VkFenceCreateInfo fenceInfo{};
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS ||
vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS ||
vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create synchronization objects for a frame.");
}
}
}
void Renderer::CleanupSyncObjects()
{
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (renderFinishedSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);
if (imageAvailableSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);
if (inFlightFences[i] != VK_NULL_HANDLE)
vkDestroyFence(device, inFlightFences[i], nullptr);
}
}
SwapChainSupportDetails Renderer::querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface)
{
SwapChainSupportDetails details;
// Query the capabilities
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
// Query the supported formats
uint32_t formatCount;
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
if (formatCount != 0)
{
details.formats.resize(formatCount);
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
}
// Query the supported present modes
uint32_t presentModeCount;
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
if (presentModeCount != 0)
{
details.presentModes.resize(presentModeCount);
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
}
return details;
}
VkSurfaceFormatKHR Renderer::chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats)
{
for (const auto& availableFormat : availableFormats)
{
if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
{
return availableFormat;
}
}
return availableFormats[0];
}
VkPresentModeKHR Renderer::chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes)
{
for (const auto& availablePresentMode : availablePresentModes)
{
if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR)
{
return availablePresentMode;
}
}
return VK_PRESENT_MODE_FIFO_KHR;
}
VkExtent2D Renderer::chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window)
{
if (capabilities.currentExtent.width != UINT32_MAX)
{
return capabilities.currentExtent;
}
else
{
int width, height;
glfwGetFramebufferSize(window, &width, &height);
VkExtent2D actualExtent = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
actualExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, actualExtent.width));
actualExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, actualExtent.height));
return actualExtent;
}
}
std::vector<const char*> Renderer::CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice)
{
uint32_t extensionCount;
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, nullptr);
std::vector<VkExtensionProperties> availableExtensions(extensionCount);
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, availableExtensions.data());
std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
for (const auto& extension : availableExtensions)
{
requiredExtensions.erase(extension.extensionName);
}
std::vector<const char*> remainingExtensions;
for (const auto& extension : requiredExtensions)
{
remainingExtensions.push_back(extension.c_str());
}
return remainingExtensions;
}
QueueFamilyIndices Renderer::GetQueueFamilyIndices(VkPhysicalDevice physicalDevice)
{
QueueFamilyIndices indices;
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr);
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilies.data());
int i = 0;
for (const auto& queueFamily : queueFamilies)
{
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
indices.graphicsFamily = i;
}
VkBool32 presentSupport = false;
vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, surface, &presentSupport);
if (presentSupport)
{
indices.presentFamily = i;
}
if (indices.IsComplete())
{
break;
}
i++;
}
return indices;
}
VkDevice* Renderer::GetDevice() {
return &device;
};
VkPhysicalDevice* Renderer::GetPhysicalDevice() {
return &physicalDevice;
};
VkCommandPool* Renderer::GetCommandPool() {
return &commandPool;
};
VkQueue* Renderer::GetGraphicsQueue() {
return &graphicsQueue;
};
VkCommandBuffer* Renderer::GetCurrentCommandBuffer() {
return ¤tCommandBuffer;
}
VkDescriptorSetLayout Renderer::CreateDescriptorSetLayout() {
VkDescriptorSetLayoutBinding uboLayoutBinding{};
uboLayoutBinding.binding = 0;
uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
uboLayoutBinding.descriptorCount = 1;
uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
uboLayoutBinding.pImmutableSamplers = nullptr;
VkDescriptorSetLayoutCreateInfo layoutInfo{};
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layoutInfo.bindingCount = 1;
layoutInfo.pBindings = &uboLayoutBinding;
VkDescriptorSetLayout descriptorSetLayout;
if (vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &descriptorSetLayout) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor set layout!");
}
return descriptorSetLayout;
}
VkDescriptorPool Renderer::CreateDescriptorPool(uint32_t maxSets) {
VkDescriptorPoolSize poolSize{};
poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
poolSize.descriptorCount = maxSets;
VkDescriptorPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
poolInfo.poolSizeCount = 1;
poolInfo.pPoolSizes = &poolSize;
poolInfo.maxSets = maxSets;
VkDescriptorPool descriptorPool;
if (vkCreateDescriptorPool(device, &poolInfo, nullptr, &descriptorPool) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor pool!");
}
return descriptorPool;
}
void Renderer::CreateGraphicsPipeline(Mesh* mesh, Material* material) {
if (pipeline)
{
pipeline->Cleanup();
}
// Create pipeline object and configure its properties
pipeline = std::make_shared<Pipeline>();
pipeline->CreateGraphicsPipeline(mesh->GetVertexInputBindingDescriptions(),
mesh->GetVertexInputAttributeDescriptions(),
swapChainExtent,
{material->GetvertexShader().get(), material->GetfragmentShader().get()},
renderPass,
material->GetPipelineLayout(),
device);
}
std::shared_ptr<Pipeline> Renderer::GetPipeline() {
return pipeline;
}
The code seems to hang at this line of code in the Renderer::BeginFrame method:
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
It does this after renderering several frames, but then just stops progressing past this line. Any ideas of what the issue could be?
|
5557df9da83206466de69a7a22630f4e
|
{
"intermediate": 0.32107990980148315,
"beginner": 0.3840792775154114,
"expert": 0.29484084248542786
}
|
8,856
|
In google sheets, I want a function for a cell that will make the content of the cell be a string that names the name of the sheet. So for example, if it's a cell in a sheet called "Sheet1" I want the cell to say "Sheet1". Is this possible? Can you make a suggestion and explain the rationale step by step?
|
f06311d69d94e27ef3c72f8f6408c2a6
|
{
"intermediate": 0.4114096164703369,
"beginner": 0.2799973487854004,
"expert": 0.3085930645465851
}
|
8,857
|
напиши бота для telegram на python, который в отдельном топике в чате в режиме топиков, который указывается через ID удаляет сообщения пользователей, которых нет в белом списке. Белый список должен быть в виде json файла. Также добавь команды, который будут доступны только администраторам группы, чтобы они могли добавлять и удалять пользователей из белого списка. Добавление пользователей в белый список должно быть через @ник пользователя, но при этом хранится в файле должны ID пользователей. И сделай, чтобы можно было добавлять людей в белый список посредством ответа на сообщения конкретного пользователя и с указанием команды добавления.
|
ed676a45fc821c5451ec9576f03243d2
|
{
"intermediate": 0.2933485805988312,
"beginner": 0.38393428921699524,
"expert": 0.32271715998649597
}
|
8,858
|
can homeyscript read data of edilife.cgi
|
0e16c6592b4617f507b3ba61c61936d1
|
{
"intermediate": 0.5402517318725586,
"beginner": 0.161915123462677,
"expert": 0.2978331446647644
}
|
8,859
|
TypeError: Button.__init__() got an unexpected keyword argument 'on_click'
|
015a477443030b82f806dd400feadd6c
|
{
"intermediate": 0.37564465403556824,
"beginner": 0.310196191072464,
"expert": 0.31415918469429016
}
|
8,860
|
I’m building a video game engine using C++ as the coding language and Vulkan for graphics. I am trying to set up a generic renderer using Vulkan that is flexible and will render objects based on a vector that is supplied to it. The renderer will also handle the creation of the window using GLFW and use GLM for all relevant math calls. I am using the ASSIMP library to load 3d models and animations.
Here is a portion of the code:
Renderer.h:
#pragma once
#include <vulkan/vulkan.h>
#include "Window.h"
#include <vector>
#include <stdexcept>
#include <set>
#include <optional>
#include <iostream>
#include "Pipeline.h"
#include "Material.h"
#include "Mesh.h"
struct QueueFamilyIndices
{
std::optional<uint32_t> graphicsFamily;
std::optional<uint32_t> presentFamily;
bool IsComplete()
{
return graphicsFamily.has_value() && presentFamily.has_value();
}
};
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities;
std::vector<VkSurfaceFormatKHR> formats;
std::vector<VkPresentModeKHR> presentModes;
};
class Renderer
{
public:
Renderer();
~Renderer();
void Initialize(GLFWwindow* window);
void Shutdown();
void BeginFrame();
void EndFrame();
VkDescriptorSetLayout CreateDescriptorSetLayout();
VkDescriptorPool CreateDescriptorPool(uint32_t maxSets);
VkDevice* GetDevice();
VkPhysicalDevice* GetPhysicalDevice();
VkCommandPool* GetCommandPool();
VkQueue* GetGraphicsQueue();
VkCommandBuffer* GetCurrentCommandBuffer();
std::shared_ptr<Pipeline> GetPipeline();
void CreateGraphicsPipeline(Mesh* mesh, Material* material);
private:
bool shutdownInProgress;
uint32_t currentCmdBufferIndex = 0;
std::vector<VkImage> swapChainImages;
std::vector<VkImageView> swapChainImageViews;
VkExtent2D swapChainExtent;
VkRenderPass renderPass;
uint32_t imageIndex;
std::shared_ptr<Pipeline> pipeline;
VkFormat swapChainImageFormat;
std::vector<VkCommandBuffer> commandBuffers;
void CreateImageViews();
void CleanupImageViews();
void CreateRenderPass();
void CleanupRenderPass();
void CreateSurface();
void DestroySurface();
void CreateInstance();
void CleanupInstance();
void ChoosePhysicalDevice();
void CreateDevice();
void CleanupDevice();
void CreateSwapchain();
void CleanupSwapchain();
void CreateCommandPool();
void CleanupCommandPool();
void CreateFramebuffers();
void CleanupFramebuffers();
void CreateCommandBuffers();
void CleanupCommandBuffers();
GLFWwindow* window;
VkInstance instance = VK_NULL_HANDLE;
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
VkDevice device = VK_NULL_HANDLE;
VkSurfaceKHR surface;
VkSwapchainKHR swapchain;
VkCommandPool commandPool;
VkCommandBuffer currentCommandBuffer;
std::vector<VkFramebuffer> framebuffers;
// Additional Vulkan objects needed for rendering…
const uint32_t kMaxFramesInFlight = 2;
std::vector<VkSemaphore> imageAvailableSemaphores;
std::vector<VkSemaphore> renderFinishedSemaphores;
std::vector<VkFence> inFlightFences;
size_t currentFrame;
VkQueue graphicsQueue;
VkQueue presentQueue;
void CreateSyncObjects();
void CleanupSyncObjects();
SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface);
VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats);
VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes);
VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window);
std::vector<const char*> deviceExtensions = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME
};
std::vector<const char*> CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice);
QueueFamilyIndices GetQueueFamilyIndices(VkPhysicalDevice physicalDevice);
};
Renderer.cpp:
#include "Renderer.h"
Renderer::Renderer() : currentFrame(0), shutdownInProgress(false)
{
}
Renderer::~Renderer()
{
Shutdown();
}
void Renderer::Initialize(GLFWwindow* window)
{
this->window = window;
CreateInstance();
CreateSurface();
ChoosePhysicalDevice();
CreateDevice();
CreateSwapchain();
CreateRenderPass();
CreateCommandPool();
CreateFramebuffers();
CreateSyncObjects();
}
void Renderer::Shutdown()
{
if (shutdownInProgress) {
return;
}
shutdownInProgress = true;
if (device != VK_NULL_HANDLE) {
vkDeviceWaitIdle(device);
}
CleanupFramebuffers();
CleanupRenderPass();
CleanupSyncObjects();
CleanupCommandBuffers();
CleanupCommandPool();
CleanupImageViews();
CleanupSwapchain();
if (device != VK_NULL_HANDLE) {
CleanupDevice();
}
DestroySurface();
CleanupInstance();
shutdownInProgress = false;
}
void Renderer::BeginFrame()
{
// Wait for any previous work on this swapchain image to complete
vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
vkResetFences(device, 1, &inFlightFences[currentFrame]);
// Acquire an image from the swapchain, then begin recording commands for the current frame.
VkResult acquireResult = vkAcquireNextImageKHR(device, swapchain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
if (acquireResult != VK_SUCCESS && acquireResult != VK_SUBOPTIMAL_KHR) {
throw std::runtime_error("Failed to acquire next swapchain image.");
}
VkCommandBufferBeginInfo beginInfo{};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
//currentCommandBuffer = commandBuffers[currentFrame];
currentCmdBufferIndex = (currentCmdBufferIndex + 1) % 2;
currentCommandBuffer = commandBuffers[currentFrame * 2 + currentCmdBufferIndex];
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
VkRenderPassBeginInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
renderPassInfo.renderPass = renderPass;
renderPassInfo.framebuffer = framebuffers[imageIndex];
renderPassInfo.renderArea.offset = { 0, 0 };
renderPassInfo.renderArea.extent = swapChainExtent;
// Set the clear color to black
VkClearValue clearColor = { 0.0f, 0.0f, 0.0f, 1.0f };
renderPassInfo.clearValueCount = 1;
renderPassInfo.pClearValues = &clearColor;
vkCmdBeginRenderPass(currentCommandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
}
void Renderer::EndFrame()
{
vkCmdEndRenderPass(currentCommandBuffer);
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &imageAvailableSemaphores[currentFrame];
submitInfo.pWaitDstStageMask = waitStages;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = ¤tCommandBuffer;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &renderFinishedSemaphores[currentFrame];
vkEndCommandBuffer(currentCommandBuffer);
vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]);
VkPresentInfoKHR presentInfo{};
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.waitSemaphoreCount = 1;
presentInfo.pWaitSemaphores = &renderFinishedSemaphores[currentFrame];
VkSwapchainKHR swapChains[] = { swapchain };
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = swapChains;
presentInfo.pImageIndices = &imageIndex;
VkResult queuePresentResult = vkQueuePresentKHR(presentQueue, &presentInfo);
if (queuePresentResult == VK_ERROR_OUT_OF_DATE_KHR || queuePresentResult == VK_SUBOPTIMAL_KHR) {
// Handle swapchain recreation if needed, e.g., due to resizing the window or other swapchain properties changes
}
else if (queuePresentResult != VK_SUCCESS) {
throw std::runtime_error("Failed to present the swapchain image.");
}
currentFrame = (currentFrame + 1) % kMaxFramesInFlight;
}
void Renderer::CreateSurface()
{
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a window surface.");
}
}
void Renderer::DestroySurface()
{
vkDestroySurfaceKHR(instance, surface, nullptr);
}
void Renderer::CreateInstance()
{
// Set up the application info
VkApplicationInfo appInfo{};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = "Game Engine";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "Game Engine";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_2;
// Set up the instance create info
VkInstanceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;
// Set up the required extensions
uint32_t glfwExtensionCount = 0;
const char** glfwExtensions;
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
createInfo.enabledExtensionCount = glfwExtensionCount;
createInfo.ppEnabledExtensionNames = glfwExtensions;
createInfo.enabledLayerCount = 0;
// Create the Vulkan instance
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create the Vulkan instance.");
}
}
void Renderer::CleanupInstance()
{
// Destroy the Vulkan instance
vkDestroyInstance(instance, nullptr);
}
void Renderer::ChoosePhysicalDevice()
{
// Enumerate the available physical devices and choose one that supports required features
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
if (deviceCount == 0)
{
throw std::runtime_error("Failed to find a GPU with Vulkan support.");
}
std::vector<VkPhysicalDevice> allDevices(deviceCount);
vkEnumeratePhysicalDevices(instance, &deviceCount, allDevices.data());
for (const auto& testDevice : allDevices)
{
if (glfwGetPhysicalDevicePresentationSupport(instance, testDevice, 0) &&
CheckPhysicalDeviceExtensionSupport(testDevice).empty() &&
GetQueueFamilyIndices(testDevice).IsComplete())
{
physicalDevice = testDevice;
break;
}
}
if (physicalDevice == VK_NULL_HANDLE)
{
throw std::runtime_error("Failed to find a suitable GPU.");
}
}
void Renderer::CreateDevice()
{
// Get the GPU’s queue family indices
const QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
// Set up the device queue create info
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
std::set<uint32_t> uniqueQueueFamilyIndices = { indices.graphicsFamily.value(),indices.presentFamily.value() };
float queuePriority = 1.0f;
for (uint32_t queueFamilyIndex : uniqueQueueFamilyIndices)
{
VkDeviceQueueCreateInfo queueCreateInfo{};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = queueFamilyIndex;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = &queuePriority;
queueCreateInfos.push_back(queueCreateInfo);
}
// Set up the physical device features
VkPhysicalDeviceFeatures deviceFeatures{};
// Set up the device create info
VkDeviceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
createInfo.pQueueCreateInfos = queueCreateInfos.data();
createInfo.pEnabledFeatures = &deviceFeatures;
createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
createInfo.ppEnabledExtensionNames = deviceExtensions.data();
// Create the logical device
if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a logical device.");
}
// Retrieve the graphics queue and the present queue
vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
}
void Renderer::CleanupDevice()
{
// Destroy the logical device
vkDestroyDevice(device, nullptr);
}
void Renderer::CreateSwapchain()
{
// Get swapchain support details
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice,surface);
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
swapChainImageFormat = surfaceFormat.format; // Initialize the swapChainImageFormat
VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities,window);
uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount)
{
imageCount = swapChainSupport.capabilities.maxImageCount;
}
// Create the swapchain
// …
VkSwapchainCreateInfoKHR createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = surface;
createInfo.minImageCount = imageCount;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() };
if (indices.graphicsFamily != indices.presentFamily) {
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
}
else {
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
}
createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapchain) != VK_SUCCESS) {
throw std::runtime_error("failed to create swap chain!");
}
// Retrieve swapchain images (color buffers)
// …
// Retrieve swapchain images
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, nullptr);
swapChainImages.resize(imageCount);
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, swapChainImages.data());
// Create image views for swapchain images
CreateImageViews();
}
void Renderer::CleanupSwapchain()
{
// Clean up Vulkan swapchain
if (swapchain != VK_NULL_HANDLE)
{
vkDestroySwapchainKHR(device, swapchain, nullptr);
swapchain = VK_NULL_HANDLE;
}
}
void Renderer::CreateImageViews()
{
swapChainImageViews.resize(swapChainImages.size());
for (size_t i = 0; i < swapChainImages.size(); ++i)
{
VkImageViewCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
createInfo.image = swapChainImages[i];
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
createInfo.format = swapChainImageFormat;
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
createInfo.subresourceRange.baseMipLevel = 0;
createInfo.subresourceRange.levelCount = 1;
createInfo.subresourceRange.baseArrayLayer = 0;
createInfo.subresourceRange.layerCount = 1;
createInfo.flags = 0;
if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create an image view.");
}
}
}
void Renderer::CleanupImageViews()
{
for (auto imageView : swapChainImageViews)
{
vkDestroyImageView(device, imageView, nullptr);
}
swapChainImageViews.clear();
}
void Renderer::CreateRenderPass()
{
VkAttachmentDescription colorAttachment{};
colorAttachment.format = swapChainImageFormat;
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
VkAttachmentReference colorAttachmentRef{};
colorAttachmentRef.attachment = 0;
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass{};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &colorAttachmentRef;
VkRenderPassCreateInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassInfo.attachmentCount = 1;
renderPassInfo.pAttachments = &colorAttachment;
renderPassInfo.subpassCount = 1;
renderPassInfo.pSubpasses = &subpass;
VkSubpassDependency dependency{};
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
dependency.dstSubpass = 0;
dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.srcAccessMask = 0;
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
renderPassInfo.dependencyCount = 1;
renderPassInfo.pDependencies = &dependency;
if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create render pass.");
}
}
void Renderer::CleanupRenderPass()
{
vkDestroyRenderPass(device, renderPass, nullptr);
}
void Renderer::CreateCommandPool()
{
// Find a queue family index that supports graphics operations
QueueFamilyIndices queueFamilyIndices = GetQueueFamilyIndices(physicalDevice);
// Create a command pool for the queue family
VkCommandPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
poolInfo.flags = 0;
if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create command pool.");
}
CreateCommandBuffers(); // Create command buffers after creating the command pool
}
void Renderer::CleanupCommandPool()
{
// Clean up Vulkan command pool
CleanupCommandBuffers(); // Add this line to clean up command buffers before destroying the command pool
vkDestroyCommandPool(device, commandPool, nullptr);
}
void Renderer::CreateCommandBuffers()
{
//commandBuffers.resize(kMaxFramesInFlight);
commandBuffers.resize(kMaxFramesInFlight * 2);
VkCommandBufferAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.commandPool = commandPool;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandBufferCount = static_cast<uint32_t>(commandBuffers.size());
if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS)
{
throw std::runtime_error("Failed to allocate command buffers.");
}
// Set the initial value of the currentCommandBuffer
currentCommandBuffer = commandBuffers[currentFrame];
}
void Renderer::CleanupCommandBuffers()
{
vkFreeCommandBuffers(device, commandPool, static_cast<uint32_t>(commandBuffers.size()), commandBuffers.data());
}
void Renderer::CreateFramebuffers()
{
// Check if the framebuffers vector is not empty, and call CleanupFramebuffers()
if (!framebuffers.empty()) {
CleanupFramebuffers();
}
// Create Vulkan framebuffers for swapchain images
framebuffers.resize(swapChainImageViews.size());
for (size_t i = 0; i < swapChainImageViews.size(); ++i)
{
VkImageView attachments[] = { swapChainImageViews[i] };
VkFramebufferCreateInfo framebufferInfo{};
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebufferInfo.renderPass = renderPass;
framebufferInfo.attachmentCount = 1;
framebufferInfo.pAttachments = attachments;
framebufferInfo.width = swapChainExtent.width;
framebufferInfo.height = swapChainExtent.height;
framebufferInfo.layers = 1;
if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &framebuffers[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create framebuffer.");
}
}
}
void Renderer::CleanupFramebuffers()
{
for (auto framebuffer : framebuffers)
{
if (framebuffer != VK_NULL_HANDLE)
{
vkDestroyFramebuffer(device, framebuffer, nullptr);
framebuffer = VK_NULL_HANDLE;
}
}
framebuffers.clear(); // Make sure to clear the framebuffers vector after destroying each framebuffer
}
void Renderer::CreateSyncObjects()
{
imageAvailableSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
renderFinishedSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
inFlightFences.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
VkSemaphoreCreateInfo semaphoreInfo{};
semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
VkFenceCreateInfo fenceInfo{};
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS ||
vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS ||
vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create synchronization objects for a frame.");
}
}
}
void Renderer::CleanupSyncObjects()
{
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (renderFinishedSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);
if (imageAvailableSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);
if (inFlightFences[i] != VK_NULL_HANDLE)
vkDestroyFence(device, inFlightFences[i], nullptr);
}
}
SwapChainSupportDetails Renderer::querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface)
{
SwapChainSupportDetails details;
// Query the capabilities
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
// Query the supported formats
uint32_t formatCount;
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
if (formatCount != 0)
{
details.formats.resize(formatCount);
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
}
// Query the supported present modes
uint32_t presentModeCount;
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
if (presentModeCount != 0)
{
details.presentModes.resize(presentModeCount);
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
}
return details;
}
VkSurfaceFormatKHR Renderer::chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats)
{
for (const auto& availableFormat : availableFormats)
{
if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
{
return availableFormat;
}
}
return availableFormats[0];
}
VkPresentModeKHR Renderer::chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes)
{
for (const auto& availablePresentMode : availablePresentModes)
{
if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR)
{
return availablePresentMode;
}
}
return VK_PRESENT_MODE_FIFO_KHR;
}
VkExtent2D Renderer::chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window)
{
if (capabilities.currentExtent.width != UINT32_MAX)
{
return capabilities.currentExtent;
}
else
{
int width, height;
glfwGetFramebufferSize(window, &width, &height);
VkExtent2D actualExtent = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
actualExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, actualExtent.width));
actualExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, actualExtent.height));
return actualExtent;
}
}
std::vector<const char*> Renderer::CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice)
{
uint32_t extensionCount;
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, nullptr);
std::vector<VkExtensionProperties> availableExtensions(extensionCount);
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, availableExtensions.data());
std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
for (const auto& extension : availableExtensions)
{
requiredExtensions.erase(extension.extensionName);
}
std::vector<const char*> remainingExtensions;
for (const auto& extension : requiredExtensions)
{
remainingExtensions.push_back(extension.c_str());
}
return remainingExtensions;
}
QueueFamilyIndices Renderer::GetQueueFamilyIndices(VkPhysicalDevice physicalDevice)
{
QueueFamilyIndices indices;
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr);
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilies.data());
int i = 0;
for (const auto& queueFamily : queueFamilies)
{
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
indices.graphicsFamily = i;
}
VkBool32 presentSupport = false;
vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, surface, &presentSupport);
if (presentSupport)
{
indices.presentFamily = i;
}
if (indices.IsComplete())
{
break;
}
i++;
}
return indices;
}
VkDevice* Renderer::GetDevice() {
return &device;
};
VkPhysicalDevice* Renderer::GetPhysicalDevice() {
return &physicalDevice;
};
VkCommandPool* Renderer::GetCommandPool() {
return &commandPool;
};
VkQueue* Renderer::GetGraphicsQueue() {
return &graphicsQueue;
};
VkCommandBuffer* Renderer::GetCurrentCommandBuffer() {
return ¤tCommandBuffer;
}
VkDescriptorSetLayout Renderer::CreateDescriptorSetLayout() {
VkDescriptorSetLayoutBinding uboLayoutBinding{};
uboLayoutBinding.binding = 0;
uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
uboLayoutBinding.descriptorCount = 1;
uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
uboLayoutBinding.pImmutableSamplers = nullptr;
VkDescriptorSetLayoutCreateInfo layoutInfo{};
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layoutInfo.bindingCount = 1;
layoutInfo.pBindings = &uboLayoutBinding;
VkDescriptorSetLayout descriptorSetLayout;
if (vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &descriptorSetLayout) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor set layout!");
}
return descriptorSetLayout;
}
VkDescriptorPool Renderer::CreateDescriptorPool(uint32_t maxSets) {
VkDescriptorPoolSize poolSize{};
poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
poolSize.descriptorCount = maxSets;
VkDescriptorPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
poolInfo.poolSizeCount = 1;
poolInfo.pPoolSizes = &poolSize;
poolInfo.maxSets = maxSets;
VkDescriptorPool descriptorPool;
if (vkCreateDescriptorPool(device, &poolInfo, nullptr, &descriptorPool) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor pool!");
}
return descriptorPool;
}
void Renderer::CreateGraphicsPipeline(Mesh* mesh, Material* material) {
if (pipeline)
{
pipeline->Cleanup();
}
// Create pipeline object and configure its properties
pipeline = std::make_shared<Pipeline>();
pipeline->CreateGraphicsPipeline(mesh->GetVertexInputBindingDescriptions(),
mesh->GetVertexInputAttributeDescriptions(),
swapChainExtent,
{material->GetvertexShader().get(), material->GetfragmentShader().get()},
renderPass,
material->GetPipelineLayout(),
device);
}
std::shared_ptr<Pipeline> Renderer::GetPipeline() {
return pipeline;
}
The code seems to hang at this line of code in the Renderer::BeginFrame method:
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
The last debug lin in the console is:
Current Frame: 1 | Cmd Buffer Index: 0 | Image Index: 0
The issue seems to occur after completing an full cycle of the image indices and cycling back to Image Index 0. Any ideas of what the issue could be?
|
d8107bf2681a8c3b5bcd6dc4c055423b
|
{
"intermediate": 0.32107990980148315,
"beginner": 0.3840792775154114,
"expert": 0.29484084248542786
}
|
8,861
|
redis lua script to intercept any get command. how?
|
56b74d7928bf64b55064d9a5be05cd0d
|
{
"intermediate": 0.49712127447128296,
"beginner": 0.2172236293554306,
"expert": 0.28565508127212524
}
|
8,862
|
def get_readings(self):
return self.send_cmd([{“id”: “get”}, {“status”: {
“temperature”: “0”,
“moisture”: 0,
“pm2.5”: 0,
“pm10”: 0,
“co2”: “0”,
“hcho”: “0”,
“tvoc”: “0”,
}}]).get(“status”, {})
# Utility functions:
def _rotate_byte(byte, rotations):
“”“Rotate byte to the left by the specified number of rotations.”“”
return (byte << rotations | byte >> (8-rotations)) & 0xFF
def _rotate_json(response):
“”“Byte rotate the Edimax response into plain JSON.”“”
# First byte always decodes to ‘{’ so the difference is the number of rotations.
rotations = response[0] - ord(‘{’)
return ‘{’ + ‘’.join(chr(_rotate_byte(byte, rotations)) for byte in response[1:])
# Testing:
def test():
“”“Example invocations.”“”
password = os.environ.get(‘EDIMAX_PASSWORD’)
if not password:
print(‘Please set environemt variable EDIMAX_PASSWORD’)
exit(1)
sensor = EdiGreenSensor.search(password)
if not sensor:
print(‘Failed to find a EdiMax sensor’)
exit(1)
print(sensor.get_readings())
sensor._log_response = True
sensor._log_request = True
# sensor.get_all()
sensor.set_led(1)
sensor.set_led(0)
if name == ‘main’:
test()
|
3df6519ea44ec5cadd62e2a118b21f58
|
{
"intermediate": 0.31604042649269104,
"beginner": 0.40283578634262085,
"expert": 0.2811238169670105
}
|
8,863
|
how to use the shaker for vibration excitation
|
783876c6530255e92f9678699c9d295c
|
{
"intermediate": 0.3368723690509796,
"beginner": 0.380031555891037,
"expert": 0.283096045255661
}
|
8,864
|
Create a cpp data driven templated/metaprogramming event system
|
02456aabe948836fe5ac2fe30f146726
|
{
"intermediate": 0.41625791788101196,
"beginner": 0.18505068123340607,
"expert": 0.3986913561820984
}
|
8,865
|
#include <stdio.h>
struct abc
{
int a, b, c;
};
int main()
{
struct abc s[2] = {{1, 2, 3}, {4, 5, 6}};
int t;
t = s[0].a + s[1].b;
printf("%d\n", t);
return 0;
}
|
86e7c1c09dd7b2935952f93e6da8d696
|
{
"intermediate": 0.31037887930870056,
"beginner": 0.5025673508644104,
"expert": 0.18705378472805023
}
|
8,866
|
homeyscript
|
97474b99f655146727193f68fd73ce93
|
{
"intermediate": 0.2800869047641754,
"beginner": 0.4011032283306122,
"expert": 0.31880983710289
}
|
8,867
|
how to create and visualize agent observation in unity in ml-agents? i have 2d top-down view arena game like brawl stars. a top-down game, the world has a strict tile structure on a grid, but players and power-ups can be placed outside of this grid. the player sees the world from above, within the radius of his player, approximately 26x17. he can see beyond the wall where his character can't shoot because the bullet will hit the wall. but there are also characters that can throw grenades, so walls are not a problem for them. I repeat once again, the player sees everything on the screen, even behind walls, because the view is from above. players are not tied to the grid, so you need to accurately track their position. offer me an observation.
I also need to use the checkbox to see the observation visualization even outside of training.
how i have this ShootingAgent.cs, modify it:
using UnityEngine;
using Unity.MLAgents;
using Unity.MLAgents.Sensors;
using Unity.MLAgents.Actuators;
public class ShootingAgent : Agent
{
public int observationResolution = 10; // The desired low-resolution observation space size
public PlayerController playerController;
private Texture2D observationTexture;
public override void OnEpisodeBegin()
{
// Reset the player and environment for a new episode
// …
playerController.InitializePlayer();
}
public override void CollectObservations(VectorSensor sensor)
{
// Capture the game view and convert it to low-resolution observation
RenderTexture renderTexture = RenderTexture.GetTemporary(observationResolution, observationResolution);
playerController.RenderToTexture(renderTexture);
RenderTexture.active = renderTexture;
observationTexture = new Texture2D(observationResolution, observationResolution, TextureFormat.RGB24, false);
observationTexture.ReadPixels(new Rect(0, 0, observationResolution, observationResolution), 0, 0);
observationTexture.Apply();
Color[] pixels = observationTexture.GetPixels();
for (int i = 0; i < pixels.Length; i++)
{
sensor.AddObservation(pixels[i].r);
sensor.AddObservation(pixels[i].g);
sensor.AddObservation(pixels[i].b);
}
RenderTexture.active = null;
RenderTexture.ReleaseTemporary(renderTexture);
// Add additional observations if needed (e.g., player’s position, bullets count, etc.)
playerController.CollectObservations(sensor);
}
public override void OnActionReceived(ActionBuffers actions)
{
// Get the joystick control values from the agent’s actions
float horizontal = actions.ContinuousActions[0];
float vertical = actions.ContinuousActions[1];
Debug.Log(horizontal);
Debug.Log(vertical);
// Use the joystick control values to control the game
playerController.ControlJoystick(horizontal, vertical);
// Set a reward based on the game state
// …
}
public override void Heuristic(in ActionBuffers actionsOut)
{
// Implement the Heuristic method for manual control (useful for debugging)
ActionSegment<float> continuousActions = actionsOut.ContinuousActions;
continuousActions[0] = Input.GetAxis("Horizontal");
continuousActions[1] = Input.GetAxis("Vertical");
}
}
|
3b800b24333dca5b268c6b878bb84734
|
{
"intermediate": 0.4371704161167145,
"beginner": 0.40855681896209717,
"expert": 0.15427272021770477
}
|
8,868
|
do you like Thatcat2000's scratch projects?
|
762c007e4365504ff271cf3ac5efb855
|
{
"intermediate": 0.37997013330459595,
"beginner": 0.2440856248140335,
"expert": 0.37594425678253174
}
|
8,869
|
create a circle on a 16x16 canvas
|
29a6f9561a39ccebf47f9d3c924339bb
|
{
"intermediate": 0.39932024478912354,
"beginner": 0.29457271099090576,
"expert": 0.3061070442199707
}
|
8,870
|
how to create and visualize agent observation in unity in ml-agents? i have 2d top-down view arena game like brawl stars. a top-down game, the world has a strict tile structure on a grid, but players and power-ups can be placed outside of this grid. the player sees the world from above, within the radius of his player, approximately 26x17. he can see beyond the wall where his character can’t shoot because the bullet will hit the wall. but there are also characters that can throw grenades, so walls are not a problem for them. I repeat once again, the player sees everything on the screen, even behind walls, because the view is from above. players are not tied to the grid, so you need to accurately track their position. offer me an observation.
I also need to use the checkbox to see the observation visualization even outside of training. you can change anything in the code, it is not necessary to leave mine, even observations.
how i have this ShootingAgent.cs, modify it:
using UnityEngine;
using Unity.MLAgents;
using Unity.MLAgents.Sensors;
using Unity.MLAgents.Actuators;
public class ShootingAgent : Agent
{
public int observationResolution = 10; // The desired low-resolution observation space size
public PlayerController playerController;
private Texture2D observationTexture;
public override void OnEpisodeBegin()
{
// Reset the player and environment for a new episode
// …
playerController.InitializePlayer();
}
public override void CollectObservations(VectorSensor sensor)
{
// Capture the game view and convert it to low-resolution observation
RenderTexture renderTexture = RenderTexture.GetTemporary(observationResolution, observationResolution);
playerController.RenderToTexture(renderTexture);
RenderTexture.active = renderTexture;
observationTexture = new Texture2D(observationResolution, observationResolution, TextureFormat.RGB24, false);
observationTexture.ReadPixels(new Rect(0, 0, observationResolution, observationResolution), 0, 0);
observationTexture.Apply();
Color[] pixels = observationTexture.GetPixels();
for (int i = 0; i < pixels.Length; i++)
{
sensor.AddObservation(pixels[i].r);
sensor.AddObservation(pixels[i].g);
sensor.AddObservation(pixels[i].b);
}
RenderTexture.active = null;
RenderTexture.ReleaseTemporary(renderTexture);
// Add additional observations if needed (e.g., player’s position, bullets count, etc.)
playerController.CollectObservations(sensor);
}
public override void OnActionReceived(ActionBuffers actions)
{
// Get the joystick control values from the agent’s actions
float horizontal = actions.ContinuousActions[0];
float vertical = actions.ContinuousActions[1];
Debug.Log(horizontal);
Debug.Log(vertical);
// Use the joystick control values to control the game
playerController.ControlJoystick(horizontal, vertical);
// Set a reward based on the game state
// …
}
public override void Heuristic(in ActionBuffers actionsOut)
{
// Implement the Heuristic method for manual control (useful for debugging)
ActionSegment<float> continuousActions = actionsOut.ContinuousActions;
continuousActions[0] = Input.GetAxis(“Horizontal”);
continuousActions[1] = Input.GetAxis(“Vertical”);
}
}
|
de2ca9cd31030815a29089ef451208b3
|
{
"intermediate": 0.5596953630447388,
"beginner": 0.29690104722976685,
"expert": 0.1434035748243332
}
|
8,871
|
improve to make it faster. Use a faster framework. Use threading. Refresh the UI more often. Just give me the resulting code. And add any improvement you can think of.
Better framework - everything is possible.
import tkinter as tk
from tkinter import ttk
from ttkthemes import ThemedTk
import subprocess
device_path = "/home/blu/broadlink/BEDROOM.device"
button_frame = None
prev_selected_device = None
def update_window_size():
if button_frame is None:
return
window.update_idletasks()
content_width = button_frame.winfo_reqwidth()
content_height = button_frame.winfo_reqheight()
# Set a minimum width and height to prevent the window from being too small
min_width = 200
min_height = 200
# Calculate the new window size by adding some padding
window_width = content_width + 20
window_height = content_height + 60
# Ensure that the window width and height are not smaller than the minimum values
window_width = max(window_width, min_width)
window_height = max(window_height, min_height)
# Get the current window position
x = window.winfo_x()
y = window.winfo_y()
# Set the window size without changing the position
window.geometry(f"{window_width}x{window_height}+{x}+{y}")
def send_data(data_path):
command = f"broadlink_cli --device @{device_path} --send @{data_path}"
subprocess.run(command, shell=True)
def on_button_click(data_path):
send_data(data_path)
def copy_command_line(data_path):
window.clipboard_clear()
command = f"broadlink_cli --device @{device_path} --send @{data_path}"
window.clipboard_append(command)
show_message_toast("Command copied to clipboard!")
def update_buttons(*args):
global button_frame, prev_selected_device
clear_buttons()
selected_device = devices_dropdown.get()
if selected_device == prev_selected_device:
return
prev_selected_device = selected_device
data_paths = devices[selected_device]
button_frame = ttk.Frame(window)
button_frame.pack(padx=10, pady=10)
row_counter = 0
col_counter = 0
max_columns = 3
for category, entries in data_paths.items():
if col_counter != 0:
row_counter += 1
col_counter = 0
category_label = ttk.Label(button_frame, text=category)
category_label.grid(row=row_counter, column=col_counter, sticky="w", padx=5, pady=5, columnspan=max_columns)
row_counter += 1
for label, path in entries.items():
button = ttk.Button(
button_frame,
text=label,
command=lambda path=path: on_button_click(path),
width=20
)
button.grid(row=row_counter, column=col_counter, padx=5, pady=(0, 5), sticky="w")
button.bind("<Button-3>", lambda event, path=path: show_context_menu(event, path))
col_counter += 1
if col_counter >= max_columns:
col_counter = 0
row_counter += 1
window.after(100, update_window_size) # Update the window size after 100 milliseconds
def show_context_menu(event, data_path):
context_menu = tk.Menu(window, tearoff=0)
context_menu.add_command(label="Copy Command Line", command=lambda: copy_command_line(data_path))
context_menu.tk_popup(event.x_root, event.y_root)
def clear_buttons():
global button_frame
if button_frame is not None:
button_frame.destroy()
button_frame = None
devices = {
"Vornado-6303DC": {
"Power": {
"Vornado On/Off": "/home/blu/broadlink/Vornado/6303DC/Vornado-on-off"
},
"Wind": {
"Vornado Wind Down": "/home/blu/broadlink/Vornado/6303DC/Vornado-wind-down",
"Vornado Wind Up": "/home/blu/broadlink/Vornado/6303DC/Vornado-wind-up"
},
"Timer": {
"Vornado Timer": "/home/blu/broadlink/Vornado/6303DC/Vornado-timer"
}
},
"RME-ADI2-DAC-FS": {
"Volume": {
"Volume Up": "/home/blu/broadlink/RME/ADI2-DAC-FS/vol+",
"Volume Down": "/home/blu/broadlink/RME/ADI2-DAC-FS/vol-"
},
"Equalizer": {
"Treble+": "/home/blu/broadlink/RME/ADI2-DAC-FS/treble+",
"Treble-": "/home/blu/broadlink/RME/ADI2-DAC-FS/treble-",
"Bass+": "/home/blu/broadlink/RME/ADI2-DAC-FS/bass+",
"Bass-": "/home/blu/broadlink/RME/ADI2-DAC-FS/bass-"
},
"Switches": {
"Toggle Headphone/Speaker": "/home/blu/broadlink/RME/ADI2-DAC-FS/RME-switch-headphone-speaker",
"Toggle Dim": "/home/blu/broadlink/RME/ADI2-DAC-FS/dim",
"Toggle Loudness": "/home/blu/broadlink/RME/ADI2-DAC-FS/loudness",
"Toggle Power": "/home/blu/broadlink/RME/ADI2-DAC-FS/power",
"Power Held": "/home/blu/broadlink/RME/ADI2-DAC-FS/power-held"
},
"Channel Balance": {
"Left Channel Balance": "/home/blu/broadlink/RME/ADI2-DAC-FS/L-chan-bal",
"Right Channel Balance": "/home/blu/broadlink/RME/ADI2-DAC-FS/r-chan-bal"
},
"Other": {
"1-ana": "/home/blu/broadlink/RME/ADI2-DAC-FS/1-ana",
"2-aes": "/home/blu/broadlink/RME/ADI2-DAC-FS/2-aes",
"3-dark": "/home/blu/broadlink/RME/ADI2-DAC-FS/3-dark",
"Select": "/home/blu/broadlink/RME/ADI2-DAC-FS/sel"
}
},
"IQAir Health Pro 250": {
"Power": {
"IQAir On/Off": "/home/blu/broadlink/IQAir/Health-Pro-250/IQAir-on-off"
},
"Filtration": {
"Filtration Level 1": "/home/blu/broadlink/IQAir/Health-Pro-250/IQAir-HealthPro-filtration-level-1",
"Filtration Level 2": "/home/blu/broadlink/IQAir/Health-Pro-250/IQAir-HealthPro-filtration-level-2",
"Filtration Level 3": "/home/blu/broadlink/IQAir/Health-Pro-250/IQAir-HealthPro-filtration-level-3",
"Filtration Level 4": "/home/blu/broadlink/IQAir/Health-Pro-250/IQAir-HealthPro-filtration-level-4",
"Filtration Level 5": "/home/blu/broadlink/IQAir/Health-Pro-250/IQAir-HealthPro-filtration-level-5",
"Filtration Level 6": "/home/blu/broadlink/IQAir/Health-Pro-250/IQAir-HealthPro-filtration-level-6"
}
},
"ezcoo-EZ-SW24-U3L": {
"PC Selection": {
"PC-1": "/home/blu/broadlink/ezcoo/EZ-SW24-U3L/ezcoo-usb-hub-pc-1",
"PC-2": "/home/blu/broadlink/ezcoo/EZ-SW24-U3L/ezcoo-usb-hub-pc-2"
}
}
}
def handle_keypress(event):
if event.keysym == "Up":
move_dropdown_selection(-1)
elif event.keysym == "Down":
move_dropdown_selection(1)
def move_dropdown_selection(offset):
current_index = devices_dropdown.current()
new_index = (current_index + offset) % len(devices)
devices_dropdown.current(new_index)
update_buttons()
def show_message_toast(message):
toast_label = ttk.Label(window, text=message)
toast_label.place(relx=0.5, rely=0.9, anchor="center")
window.after(2000, lambda: toast_label.destroy())
window = ThemedTk(theme="arc") # Specify the desired theme ("arc" in this example)
window.title("Broadlink Device Control")
window.geometry("400x400")
window.bind("<KeyPress>", handle_keypress)
selected_device = tk.StringVar(window)
devices_dropdown = ttk.Combobox(window, textvariable=selected_device)
devices_dropdown.pack(pady=10)
devices_dropdown["values"] = tuple(devices.keys())
devices_dropdown.current(0)
devices_dropdown.bind("<<ComboboxSelected>>", update_buttons)
window.after(100, update_window_size) # Update the window size after 100 milliseconds
window.mainloop()
|
d41bf2d8f95eb22d210869592f771c2f
|
{
"intermediate": 0.5051383376121521,
"beginner": 0.26048892736434937,
"expert": 0.23437273502349854
}
|
8,872
|
flutter show dropdown menu on click in image how?
|
fbe8633d05913825653a57f19c535ae0
|
{
"intermediate": 0.4622189998626709,
"beginner": 0.1712855100631714,
"expert": 0.36649543046951294
}
|
8,873
|
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
Cell In [20], line 10
8 import time
9 start = time.time()
---> 10 state = trainer.initialize()
11 #state.model.assign_weights_to(model_fn)
12 train_hist = []
File ~\AppData\Roaming\Python\Python38\site-packages\tensorflow_federated\python\core\impl\utils\function_utils.py:521, in ConcreteFunction.__call__(self, *args, **kwargs)
519 context = self._context_stack.current
520 arg = pack_args(self._type_signature.parameter, args, kwargs, context)
--> 521 return context.invoke(self, arg)
File ~\AppData\Roaming\Python\Python38\site-packages\tensorflow_federated\python\core\impl\tensorflow_context\tensorflow_computation_context.py:50, in TensorFlowComputationContext.invoke(self, comp, arg)
47 py_typecheck.check_type(comp, computation_base.Computation)
48 computation_proto = computation_impl.ComputationImpl.get_proto(comp)
49 init_op, result = (
---> 50 tensorflow_deserialization.deserialize_and_call_tf_computation(
51 computation_proto, arg, self._graph))
52 if init_op:
53 self._init_ops.append(init_op)
File ~\AppData\Roaming\Python\Python38\site-packages\tensorflow_federated\python\core\impl\tensorflow_deserialization.py:66, in deserialize_and_call_tf_computation(computation_proto, arg, graph)
64 computation_oneof = computation_proto.WhichOneof('computation')
65 if computation_oneof != 'tensorflow':
---> 66 raise ValueError(
67 'Expected a TensorFlow computation, got {}.'.format(computation_oneof))
68 py_typecheck.check_type(graph, tf.Graph)
69 with graph.as_default():
ValueError: Expected a TensorFlow computation, got lambda.
|
d5f51b14ebe76848423fa7c4c44b1c7a
|
{
"intermediate": 0.5142338275909424,
"beginner": 0.24903292953968048,
"expert": 0.23673325777053833
}
|
8,874
|
POST /resweb/component/dynamicQuery.spr?method=doDyncQryData&resTypeId=9435&dt=1684977942400 HTTP/1.1
Referer: http://10.35.35.43:7016/resweb/component/dynamicPage/dynamicQuery/modalQuery.jsp?
|
1b4b6ff52af0630d77f37ba738b7de17
|
{
"intermediate": 0.4793170988559723,
"beginner": 0.2966466248035431,
"expert": 0.2240362912416458
}
|
8,875
|
улучши этот код
public Scores[] GetScore(GetScoresOptions options) {
string url = "https://osu.ppy.sh/api/get_scores";
Dictionary<string, string> query = new Dictionary<string, string>() {
{ "k", AccessToken },
{ "b", options.BeatmapId?.ToString() },
{ "u", options.User },
{ "m", ((int)options.Mode).ToString() },
{ "mods", options.Mods?.ToString() },
{ "type", options.Type},
{ "limit", options.Limit?.ToString() }
};
return get<Scores[]>(url, query.Where(kv => kv.Value != null));
}
public async Task<Scores[]> GetScoreAsync(GetScoresOptions options) {
string url = "https://osu.ppy.sh/api/get_scores";
Dictionary<string, string> query = new Dictionary<string, string>() {
{ "k", AccessToken },
{ "b", options.BeatmapId?.ToString() },
{ "u", options.User },
{ "m", ((int)options.Mode).ToString() },
{ "mods", options.Mods?.ToString() },
{ "type", options.Type},
{ "limit", options.Limit?.ToString() }
};
return await getAsync<Scores[]>(url, query.Where(kv => kv.Value != null));
}
|
533ecb135854bb82b934af7280dbdfc0
|
{
"intermediate": 0.4205076992511749,
"beginner": 0.32404765486717224,
"expert": 0.2554446756839752
}
|
8,876
|
fastapi and swagger handling error, for example 1. data already exist, 2. data type error, 3. data field missing
|
0e9645e6f35d06c2da4d1aa02eee0c68
|
{
"intermediate": 0.7179094552993774,
"beginner": 0.08053629845380783,
"expert": 0.2015542984008789
}
|
8,877
|
What would be the next steps I should take to progress and develop this ecs? #pragma once
#include <cstdint>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <bitset>
#include <typeinfo>
#include “System.h”
#include “Archetype.h”
#include “ComponentMask.h”
typedef std::vector<int> ArchetypeId;
class ECS
{
private:
typedef std::unordered_map<std::uint8_t, std::vector<SystemBase*>>
SystemsArrayMap;
typedef std::unordered_map<std::size_t, ComponentBase*>
ComponentTypeIdBaseMap;
struct Record
{
Archetype* archetype;
std::size_t index;
};
typedef std::unordered_map<std::size_t, Record> EntityArchetypeMap;
typedef std::vector<Archetype*> ArchetypesArray;
typedef std::unordered_map<std::size_t, ComponentMask> ComponentMasks;
public:
explicit ECS();
~ECS();
void Update(const std::uint8_t layer, const std::uint32_t delta);
void RegisterEntity(const uint32_t entityId);
void DestroyEntity(const std::uint32_t entityId);
template <class C>
void RegisterComponent();
template <class C>
bool IsComponentRegistered();
template<class C, typename… Args>
C* AddComponent(const uint32_t entityId, Args&&… args);
template<class C>
void RemoveComponent(const uint32_t entityId);
template<class C>
C* GetComponent(const uint32_t entityId);
template<class C>
bool HasComponent(const uint32_t entityId);
void RegisterSystem(const std::uint8_t& layer, SystemBase* system);
void UnregisterSystem(const std::uint8_t& layer, SystemBase* system);
template<class… Cs>
std::vector<uint32_t> GetEntitiesWithComponents();
Archetype* GetArchetype(const ComponentMask& compMask);
std::uint32_t GetNewId();
private:
std::uint32_t entityIdCounter;
SystemsArrayMap systems;
EntityArchetypeMap entityArchetypeMap;
ArchetypesArray archetypes;
ComponentMasks componentMasks;
ComponentTypeIdBaseMap componentMap;
void Reallocate(const ComponentBase* compbase, const size_t& newCompSize, Archetype* arch, size_t index);
void TransferComponentData(const ComponentBase* compbase, Archetype* fromArch, Archetype* toArch, size_t i, size_t j, size_t entityIndex);
void SwapComponentData(const ComponentBase* compbase, Archetype* arch, size_t i, size_t entityIndex);
void RemoveAndAllocateComponentData(const ComponentBase* compbase, Archetype* fromArch, Archetype* toArch, size_t i, size_t j, size_t entityIndex);
};
class SystemBase
{
public:
virtual ~SystemBase() {}
virtual ComponentMask GetComponentMask() const = 0;
virtual void Update(const std::uint32_t elapsedTime, Archetype* archetype) = 0;
};
class ECS;
template<class… Cs>
class System : public SystemBase
{
public:
friend class ECS;
typedef std::function<void(const std::uint32_t, const std::vector<uint32_t>&, Cs*…)> Func;
System(ECS& ecs, const std::uint8_t& layer);
virtual ComponentMask GetComponentMask() const override;
void Action(Func func);
protected:
template<std::size_t Index1, typename T, typename… Ts>
std::enable_if_t<Index1 == sizeof…(Cs)>
Update(const std::uint32_t elapsedMilliseconds,
const ComponentMask& componentMask,
const std::vector<uint32_t>& entityIds,
T& t,
Ts… ts);
template<std::size_t Index1, typename T, typename… Ts>
std::enable_if_t<Index1 != sizeof…(Cs)>
Update(const std::uint32_t elapsedMilliseconds,
const ComponentMask& componentMask,
const std::vector<uint32_t>& entityIds,
T& t,
Ts… ts);
virtual void Update(const std::uint32_t elapsedMilliseconds,
Archetype* archetype) override;
ECS& ecs_;
ComponentMask componentMask_;
Func func_;
bool funcStatus_;
};
template<class… Cs>
System<Cs…>::System(ECS& ecs, const std::uint8_t& layer)
: ecs_(ecs), funcStatus_(false)
{
ecs_.RegisterSystem(layer, this);
((componentMask_.AddComponent(GetTypeID<Cs>())), …);
}
typedef unsigned char* ComponentData;
typedef std::vector<int> ArchetypeId;
struct Archetype
{
ComponentMask componentMask;
std::vector<ComponentData> componentData;
std::vector<uint32_t> entityIds;
std::vector<std::size_t> componentDataSize;
};class ComponentBase
{
public:
virtual ~ComponentBase() {}
virtual void DestroyData(unsigned char* data) const = 0;
virtual void MoveData(unsigned char* source, unsigned char* destination) const = 0;
virtual void ConstructData(unsigned char* data) const = 0;
virtual std::size_t GetSize() const = 0;
};
template<class C>
class Component : public ComponentBase
{
public:
virtual void DestroyData(unsigned char* data) const override;
virtual void MoveData(unsigned char* source, unsigned char* destination) const override;
virtual void ConstructData(unsigned char* data) const override;
virtual std::size_t GetSize() const override;
static std::size_t GetTypeID();
};
template<class C>
void Component<C>::DestroyData(unsigned char* data) const
{
C* dataLocation = std::launder(reinterpret_cast<C*>(data));
dataLocation->~C();
}
template<class C>
void Component<C>::ConstructData(unsigned char* data) const
{
new (&data[0]) C();
}
template<class C>
void Component<C>::MoveData(unsigned char* source, unsigned char* destination) const
{
new (&destination[0]) C(std::move(std::bit_cast<C>(source)));
}
template<class C>
std::size_t Component<C>::GetSize() const
{
return sizeof©;
}
template<class C>
std::size_t Component<C>::GetTypeID()
{
return TypeIdGenerator<ComponentBase>::GetNewID<C>();
}
template <class C>
std::size_t GetTypeID() {
return TypeIdGenerator<ComponentBase>::GetNewID<C>();
}
|
eaed32c670aeccbd5280f217872e26d1
|
{
"intermediate": 0.3250514268875122,
"beginner": 0.4096217453479767,
"expert": 0.2653268873691559
}
|
8,878
|
I’m building a video game engine using C++ as the coding language and Vulkan for graphics. I am trying to set up a generic renderer using Vulkan that is flexible and will render objects based on a vector that is supplied to it. The renderer will also handle the creation of the window using GLFW and use GLM for all relevant math calls. I am using the ASSIMP library to load 3d models and animations.
Here is a portion of the code:
Renderer.h:
#pragma once
#include <vulkan/vulkan.h>
#include "Window.h"
#include <vector>
#include <stdexcept>
#include <set>
#include <optional>
#include <iostream>
#include "Pipeline.h"
#include "Material.h"
#include "Mesh.h"
struct QueueFamilyIndices
{
std::optional<uint32_t> graphicsFamily;
std::optional<uint32_t> presentFamily;
bool IsComplete()
{
return graphicsFamily.has_value() && presentFamily.has_value();
}
};
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities;
std::vector<VkSurfaceFormatKHR> formats;
std::vector<VkPresentModeKHR> presentModes;
};
class Renderer
{
public:
Renderer();
~Renderer();
void Initialize(GLFWwindow* window);
void Shutdown();
void BeginFrame();
void EndFrame();
VkDescriptorSetLayout CreateDescriptorSetLayout();
VkDescriptorPool CreateDescriptorPool(uint32_t maxSets);
VkDevice* GetDevice();
VkPhysicalDevice* GetPhysicalDevice();
VkCommandPool* GetCommandPool();
VkQueue* GetGraphicsQueue();
VkCommandBuffer* GetCurrentCommandBuffer();
std::shared_ptr<Pipeline> GetPipeline();
void CreateGraphicsPipeline(Mesh* mesh, Material* material);
private:
bool shutdownInProgress;
uint32_t currentCmdBufferIndex = 0;
std::vector<VkImage> swapChainImages;
std::vector<VkImageView> swapChainImageViews;
VkExtent2D swapChainExtent;
VkRenderPass renderPass;
uint32_t imageIndex;
std::shared_ptr<Pipeline> pipeline;
VkFormat swapChainImageFormat;
std::vector<VkCommandBuffer> commandBuffers;
void CreateImageViews();
void CleanupImageViews();
void CreateRenderPass();
void CleanupRenderPass();
void CreateSurface();
void DestroySurface();
void CreateInstance();
void CleanupInstance();
void ChoosePhysicalDevice();
void CreateDevice();
void CleanupDevice();
void CreateSwapchain();
void CleanupSwapchain();
void CreateCommandPool();
void CleanupCommandPool();
void CreateFramebuffers();
void CleanupFramebuffers();
void CreateCommandBuffers();
void CleanupCommandBuffers();
GLFWwindow* window;
VkInstance instance = VK_NULL_HANDLE;
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
VkDevice device = VK_NULL_HANDLE;
VkSurfaceKHR surface;
VkSwapchainKHR swapchain;
VkCommandPool commandPool;
VkCommandBuffer currentCommandBuffer;
std::vector<VkFramebuffer> framebuffers;
// Additional Vulkan objects needed for rendering…
const uint32_t kMaxFramesInFlight = 2;
std::vector<VkSemaphore> imageAvailableSemaphores;
std::vector<VkSemaphore> renderFinishedSemaphores;
std::vector<VkFence> inFlightFences;
size_t currentFrame;
VkQueue graphicsQueue;
VkQueue presentQueue;
void CreateSyncObjects();
void CleanupSyncObjects();
SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface);
VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats);
VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes);
VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window);
std::vector<const char*> deviceExtensions = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME
};
std::vector<const char*> CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice);
QueueFamilyIndices GetQueueFamilyIndices(VkPhysicalDevice physicalDevice);
};
Renderer.cpp:
#include "Renderer.h"
Renderer::Renderer() : currentFrame(0), shutdownInProgress(false)
{
}
Renderer::~Renderer()
{
Shutdown();
}
void Renderer::Initialize(GLFWwindow* window)
{
this->window = window;
CreateInstance();
CreateSurface();
ChoosePhysicalDevice();
CreateDevice();
CreateSwapchain();
CreateRenderPass();
CreateCommandPool();
CreateFramebuffers();
CreateSyncObjects();
}
void Renderer::Shutdown()
{
if (shutdownInProgress) {
return;
}
shutdownInProgress = true;
if (device != VK_NULL_HANDLE) {
vkDeviceWaitIdle(device);
}
CleanupFramebuffers();
CleanupRenderPass();
CleanupSyncObjects();
CleanupCommandBuffers();
CleanupCommandPool();
CleanupImageViews();
CleanupSwapchain();
if (device != VK_NULL_HANDLE) {
CleanupDevice();
}
DestroySurface();
CleanupInstance();
shutdownInProgress = false;
}
void Renderer::BeginFrame()
{
// Wait for any previous work on this swapchain image to complete
vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
vkResetFences(device, 1, &inFlightFences[currentFrame]);
// Acquire an image from the swapchain, then begin recording commands for the current frame.
VkResult acquireResult = vkAcquireNextImageKHR(device, swapchain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
if (acquireResult != VK_SUCCESS && acquireResult != VK_SUBOPTIMAL_KHR) {
throw std::runtime_error("Failed to acquire next swapchain image.");
}
VkCommandBufferBeginInfo beginInfo{};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
//currentCommandBuffer = commandBuffers[currentFrame];
currentCmdBufferIndex = (currentCmdBufferIndex + 1) % 2;
currentCommandBuffer = commandBuffers[currentFrame * 2 + currentCmdBufferIndex];
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
VkRenderPassBeginInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
renderPassInfo.renderPass = renderPass;
renderPassInfo.framebuffer = framebuffers[imageIndex];
renderPassInfo.renderArea.offset = { 0, 0 };
renderPassInfo.renderArea.extent = swapChainExtent;
// Set the clear color to black
VkClearValue clearColor = { 0.0f, 0.0f, 0.0f, 1.0f };
renderPassInfo.clearValueCount = 1;
renderPassInfo.pClearValues = &clearColor;
vkCmdBeginRenderPass(currentCommandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
}
void Renderer::EndFrame()
{
vkCmdEndRenderPass(currentCommandBuffer);
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &imageAvailableSemaphores[currentFrame];
submitInfo.pWaitDstStageMask = waitStages;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = ¤tCommandBuffer;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &renderFinishedSemaphores[currentFrame];
vkEndCommandBuffer(currentCommandBuffer);
vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]);
VkPresentInfoKHR presentInfo{};
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.waitSemaphoreCount = 1;
presentInfo.pWaitSemaphores = &renderFinishedSemaphores[currentFrame];
VkSwapchainKHR swapChains[] = { swapchain };
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = swapChains;
presentInfo.pImageIndices = &imageIndex;
VkResult queuePresentResult = vkQueuePresentKHR(presentQueue, &presentInfo);
if (queuePresentResult == VK_ERROR_OUT_OF_DATE_KHR || queuePresentResult == VK_SUBOPTIMAL_KHR) {
// Handle swapchain recreation if needed, e.g., due to resizing the window or other swapchain properties changes
}
else if (queuePresentResult != VK_SUCCESS) {
throw std::runtime_error("Failed to present the swapchain image.");
}
currentFrame = (currentFrame + 1) % kMaxFramesInFlight;
}
void Renderer::CreateSurface()
{
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a window surface.");
}
}
void Renderer::DestroySurface()
{
vkDestroySurfaceKHR(instance, surface, nullptr);
}
void Renderer::CreateInstance()
{
// Set up the application info
VkApplicationInfo appInfo{};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = "Game Engine";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "Game Engine";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_2;
// Set up the instance create info
VkInstanceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;
// Set up the required extensions
uint32_t glfwExtensionCount = 0;
const char** glfwExtensions;
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
createInfo.enabledExtensionCount = glfwExtensionCount;
createInfo.ppEnabledExtensionNames = glfwExtensions;
createInfo.enabledLayerCount = 0;
// Create the Vulkan instance
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create the Vulkan instance.");
}
}
void Renderer::CleanupInstance()
{
// Destroy the Vulkan instance
vkDestroyInstance(instance, nullptr);
}
void Renderer::ChoosePhysicalDevice()
{
// Enumerate the available physical devices and choose one that supports required features
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
if (deviceCount == 0)
{
throw std::runtime_error("Failed to find a GPU with Vulkan support.");
}
std::vector<VkPhysicalDevice> allDevices(deviceCount);
vkEnumeratePhysicalDevices(instance, &deviceCount, allDevices.data());
for (const auto& testDevice : allDevices)
{
if (glfwGetPhysicalDevicePresentationSupport(instance, testDevice, 0) &&
CheckPhysicalDeviceExtensionSupport(testDevice).empty() &&
GetQueueFamilyIndices(testDevice).IsComplete())
{
physicalDevice = testDevice;
break;
}
}
if (physicalDevice == VK_NULL_HANDLE)
{
throw std::runtime_error("Failed to find a suitable GPU.");
}
}
void Renderer::CreateDevice()
{
// Get the GPU’s queue family indices
const QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
// Set up the device queue create info
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
std::set<uint32_t> uniqueQueueFamilyIndices = { indices.graphicsFamily.value(),indices.presentFamily.value() };
float queuePriority = 1.0f;
for (uint32_t queueFamilyIndex : uniqueQueueFamilyIndices)
{
VkDeviceQueueCreateInfo queueCreateInfo{};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = queueFamilyIndex;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = &queuePriority;
queueCreateInfos.push_back(queueCreateInfo);
}
// Set up the physical device features
VkPhysicalDeviceFeatures deviceFeatures{};
// Set up the device create info
VkDeviceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
createInfo.pQueueCreateInfos = queueCreateInfos.data();
createInfo.pEnabledFeatures = &deviceFeatures;
createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
createInfo.ppEnabledExtensionNames = deviceExtensions.data();
// Create the logical device
if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a logical device.");
}
// Retrieve the graphics queue and the present queue
vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
}
void Renderer::CleanupDevice()
{
// Destroy the logical device
vkDestroyDevice(device, nullptr);
}
void Renderer::CreateSwapchain()
{
// Get swapchain support details
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice,surface);
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
swapChainImageFormat = surfaceFormat.format; // Initialize the swapChainImageFormat
VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities,window);
uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount)
{
imageCount = swapChainSupport.capabilities.maxImageCount;
}
// Create the swapchain
// …
VkSwapchainCreateInfoKHR createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = surface;
createInfo.minImageCount = imageCount;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() };
if (indices.graphicsFamily != indices.presentFamily) {
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
}
else {
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
}
createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapchain) != VK_SUCCESS) {
throw std::runtime_error("failed to create swap chain!");
}
// Retrieve swapchain images (color buffers)
// …
// Retrieve swapchain images
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, nullptr);
swapChainImages.resize(imageCount);
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, swapChainImages.data());
// Create image views for swapchain images
CreateImageViews();
}
void Renderer::CleanupSwapchain()
{
// Clean up Vulkan swapchain
if (swapchain != VK_NULL_HANDLE)
{
vkDestroySwapchainKHR(device, swapchain, nullptr);
swapchain = VK_NULL_HANDLE;
}
}
void Renderer::CreateImageViews()
{
swapChainImageViews.resize(swapChainImages.size());
for (size_t i = 0; i < swapChainImages.size(); ++i)
{
VkImageViewCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
createInfo.image = swapChainImages[i];
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
createInfo.format = swapChainImageFormat;
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
createInfo.subresourceRange.baseMipLevel = 0;
createInfo.subresourceRange.levelCount = 1;
createInfo.subresourceRange.baseArrayLayer = 0;
createInfo.subresourceRange.layerCount = 1;
createInfo.flags = 0;
if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create an image view.");
}
}
}
void Renderer::CleanupImageViews()
{
for (auto imageView : swapChainImageViews)
{
vkDestroyImageView(device, imageView, nullptr);
}
swapChainImageViews.clear();
}
void Renderer::CreateRenderPass()
{
VkAttachmentDescription colorAttachment{};
colorAttachment.format = swapChainImageFormat;
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
VkAttachmentReference colorAttachmentRef{};
colorAttachmentRef.attachment = 0;
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass{};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &colorAttachmentRef;
VkRenderPassCreateInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassInfo.attachmentCount = 1;
renderPassInfo.pAttachments = &colorAttachment;
renderPassInfo.subpassCount = 1;
renderPassInfo.pSubpasses = &subpass;
VkSubpassDependency dependency{};
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
dependency.dstSubpass = 0;
dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.srcAccessMask = 0;
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
renderPassInfo.dependencyCount = 1;
renderPassInfo.pDependencies = &dependency;
if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create render pass.");
}
}
void Renderer::CleanupRenderPass()
{
vkDestroyRenderPass(device, renderPass, nullptr);
}
void Renderer::CreateCommandPool()
{
// Find a queue family index that supports graphics operations
QueueFamilyIndices queueFamilyIndices = GetQueueFamilyIndices(physicalDevice);
// Create a command pool for the queue family
VkCommandPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
poolInfo.flags = 0;
if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create command pool.");
}
CreateCommandBuffers(); // Create command buffers after creating the command pool
}
void Renderer::CleanupCommandPool()
{
// Clean up Vulkan command pool
CleanupCommandBuffers(); // Add this line to clean up command buffers before destroying the command pool
vkDestroyCommandPool(device, commandPool, nullptr);
}
void Renderer::CreateCommandBuffers()
{
//commandBuffers.resize(kMaxFramesInFlight);
commandBuffers.resize(kMaxFramesInFlight * 2);
VkCommandBufferAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.commandPool = commandPool;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandBufferCount = static_cast<uint32_t>(commandBuffers.size());
if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS)
{
throw std::runtime_error("Failed to allocate command buffers.");
}
// Set the initial value of the currentCommandBuffer
currentCommandBuffer = commandBuffers[currentFrame];
}
void Renderer::CleanupCommandBuffers()
{
vkFreeCommandBuffers(device, commandPool, static_cast<uint32_t>(commandBuffers.size()), commandBuffers.data());
}
void Renderer::CreateFramebuffers()
{
// Check if the framebuffers vector is not empty, and call CleanupFramebuffers()
if (!framebuffers.empty()) {
CleanupFramebuffers();
}
// Create Vulkan framebuffers for swapchain images
framebuffers.resize(swapChainImageViews.size());
for (size_t i = 0; i < swapChainImageViews.size(); ++i)
{
VkImageView attachments[] = { swapChainImageViews[i] };
VkFramebufferCreateInfo framebufferInfo{};
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebufferInfo.renderPass = renderPass;
framebufferInfo.attachmentCount = 1;
framebufferInfo.pAttachments = attachments;
framebufferInfo.width = swapChainExtent.width;
framebufferInfo.height = swapChainExtent.height;
framebufferInfo.layers = 1;
if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &framebuffers[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create framebuffer.");
}
}
}
void Renderer::CleanupFramebuffers()
{
for (auto framebuffer : framebuffers)
{
if (framebuffer != VK_NULL_HANDLE)
{
vkDestroyFramebuffer(device, framebuffer, nullptr);
framebuffer = VK_NULL_HANDLE;
}
}
framebuffers.clear(); // Make sure to clear the framebuffers vector after destroying each framebuffer
}
void Renderer::CreateSyncObjects()
{
imageAvailableSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
renderFinishedSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
inFlightFences.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
VkSemaphoreCreateInfo semaphoreInfo{};
semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
VkFenceCreateInfo fenceInfo{};
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS ||
vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS ||
vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create synchronization objects for a frame.");
}
}
}
void Renderer::CleanupSyncObjects()
{
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (renderFinishedSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);
if (imageAvailableSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);
if (inFlightFences[i] != VK_NULL_HANDLE)
vkDestroyFence(device, inFlightFences[i], nullptr);
}
}
SwapChainSupportDetails Renderer::querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface)
{
SwapChainSupportDetails details;
// Query the capabilities
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
// Query the supported formats
uint32_t formatCount;
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
if (formatCount != 0)
{
details.formats.resize(formatCount);
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
}
// Query the supported present modes
uint32_t presentModeCount;
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
if (presentModeCount != 0)
{
details.presentModes.resize(presentModeCount);
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
}
return details;
}
VkSurfaceFormatKHR Renderer::chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats)
{
for (const auto& availableFormat : availableFormats)
{
if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
{
return availableFormat;
}
}
return availableFormats[0];
}
VkPresentModeKHR Renderer::chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes)
{
for (const auto& availablePresentMode : availablePresentModes)
{
if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR)
{
return availablePresentMode;
}
}
return VK_PRESENT_MODE_FIFO_KHR;
}
VkExtent2D Renderer::chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window)
{
if (capabilities.currentExtent.width != UINT32_MAX)
{
return capabilities.currentExtent;
}
else
{
int width, height;
glfwGetFramebufferSize(window, &width, &height);
VkExtent2D actualExtent = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
actualExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, actualExtent.width));
actualExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, actualExtent.height));
return actualExtent;
}
}
std::vector<const char*> Renderer::CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice)
{
uint32_t extensionCount;
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, nullptr);
std::vector<VkExtensionProperties> availableExtensions(extensionCount);
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, availableExtensions.data());
std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
for (const auto& extension : availableExtensions)
{
requiredExtensions.erase(extension.extensionName);
}
std::vector<const char*> remainingExtensions;
for (const auto& extension : requiredExtensions)
{
remainingExtensions.push_back(extension.c_str());
}
return remainingExtensions;
}
QueueFamilyIndices Renderer::GetQueueFamilyIndices(VkPhysicalDevice physicalDevice)
{
QueueFamilyIndices indices;
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr);
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilies.data());
int i = 0;
for (const auto& queueFamily : queueFamilies)
{
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
indices.graphicsFamily = i;
}
VkBool32 presentSupport = false;
vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, surface, &presentSupport);
if (presentSupport)
{
indices.presentFamily = i;
}
if (indices.IsComplete())
{
break;
}
i++;
}
return indices;
}
VkDevice* Renderer::GetDevice() {
return &device;
};
VkPhysicalDevice* Renderer::GetPhysicalDevice() {
return &physicalDevice;
};
VkCommandPool* Renderer::GetCommandPool() {
return &commandPool;
};
VkQueue* Renderer::GetGraphicsQueue() {
return &graphicsQueue;
};
VkCommandBuffer* Renderer::GetCurrentCommandBuffer() {
return ¤tCommandBuffer;
}
VkDescriptorSetLayout Renderer::CreateDescriptorSetLayout() {
VkDescriptorSetLayoutBinding uboLayoutBinding{};
uboLayoutBinding.binding = 0;
uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
uboLayoutBinding.descriptorCount = 1;
uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
uboLayoutBinding.pImmutableSamplers = nullptr;
VkDescriptorSetLayoutCreateInfo layoutInfo{};
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layoutInfo.bindingCount = 1;
layoutInfo.pBindings = &uboLayoutBinding;
VkDescriptorSetLayout descriptorSetLayout;
if (vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &descriptorSetLayout) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor set layout!");
}
return descriptorSetLayout;
}
VkDescriptorPool Renderer::CreateDescriptorPool(uint32_t maxSets) {
VkDescriptorPoolSize poolSize{};
poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
poolSize.descriptorCount = maxSets;
VkDescriptorPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
poolInfo.poolSizeCount = 1;
poolInfo.pPoolSizes = &poolSize;
poolInfo.maxSets = maxSets;
VkDescriptorPool descriptorPool;
if (vkCreateDescriptorPool(device, &poolInfo, nullptr, &descriptorPool) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor pool!");
}
return descriptorPool;
}
void Renderer::CreateGraphicsPipeline(Mesh* mesh, Material* material) {
if (pipeline)
{
pipeline->Cleanup();
}
// Create pipeline object and configure its properties
pipeline = std::make_shared<Pipeline>();
pipeline->CreateGraphicsPipeline(mesh->GetVertexInputBindingDescriptions(),
mesh->GetVertexInputAttributeDescriptions(),
swapChainExtent,
{material->GetvertexShader().get(), material->GetfragmentShader().get()},
renderPass,
material->GetPipelineLayout(),
device);
}
std::shared_ptr<Pipeline> Renderer::GetPipeline() {
return pipeline;
}
The code seems to hang at this line of code in the Renderer::BeginFrame method:
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
The last debug line in the console is:
Current Frame: 1 | Cmd Buffer Index: 0 | Image Index: 0
The issue seems to occur after completing an full cycle of the image indices and cycling back to Image Index 0. Can you check that the CreateSyncObjects method is workign correctly? I believe the issue might be in the way it is trying to sync swapchain images.
|
86569fb9572e0d391c7ce2ed80d20c28
|
{
"intermediate": 0.32107990980148315,
"beginner": 0.3840792775154114,
"expert": 0.29484084248542786
}
|
8,879
|
push w key and s key once randomly and wiggle mouse python
|
b4c4c1688eed8cf1fd8c4977960e7f76
|
{
"intermediate": 0.39949655532836914,
"beginner": 0.25348421931266785,
"expert": 0.347019225358963
}
|
8,880
|
26287 segmentation fault
|
7f868e9533634218a8472aa2a6ad22ec
|
{
"intermediate": 0.30496305227279663,
"beginner": 0.4222681522369385,
"expert": 0.2727687954902649
}
|
8,881
|
как добавить прозрачность точкам с материалом:
const pointMaterial = new THREE.ShaderMaterial({
uniforms:uniforms2,
fragmentShader:shaderCode,
sizeAttenuation: true,
map: texturePoint,
alphaTest: 0.1,
transparent: true,
color: new THREE.Color(1., 1., 1.),
side: THREE.DoubleSide,
opacity: 0.5
});
|
230b1af667e3a3df5863f3005542083a
|
{
"intermediate": 0.37980183959007263,
"beginner": 0.2492242157459259,
"expert": 0.3709739148616791
}
|
8,882
|
39 57 C:\Users\22269\Documents\Untitled1.cpp [Error] could not convert '{1, 8, 6, 2, 5, 4, 8, 3, 7}' from '<brace-enclosed initializer list>' to 'std::vector<int>'
|
8675a9816fc937bd074d6ad27b3ebaa3
|
{
"intermediate": 0.338206946849823,
"beginner": 0.442719966173172,
"expert": 0.21907305717468262
}
|
8,883
|
I want to move to a location offset from the center of my sphere/aoe as my attack range. How can I achieve that using UE5 and GAS? Basically, I have the center of an aoe sphere and I want to move to that location + an offset based on the attack range of that ability. So I will move towards the center and based on my attack range a bit closer from the direction of my character so I can start casting the ability.
|
d911884b38dff6efa839642e40391508
|
{
"intermediate": 0.6909414529800415,
"beginner": 0.13346579670906067,
"expert": 0.1755928099155426
}
|
8,884
|
so, if you place negative swastika on positive swastika you will get a polygon of four squares… and in cube there’s a total of 12 cubes.
I’m sorry, but I’m not quite sure what you mean. The swastika is a symbol with various meanings and associations in different cultures, and its appearance can vary depending on its orientation and context. However, I’m not aware of any geometric or mathematical relationship between the swastika and cubes. Can you please provide more context or information about your question?
just calculating… maybe you can hlp, except saying that?
I apologize if my previous response was not helpful. Could you please provide more context or information about what you are trying to calculate or understand?
if you place negative swastika on positive swastika you will get a polygon of four squares, right?
I’m sorry, but I’m not sure that is correct. The swastika is a symbol consisting of a cross with arms at right angles, typically clockwise or counterclockwise in orientation. Placing the negative swastika on the positive swastika may result in a different symbol or shape, but it would not necessarily be a polygon of four squares. Without further information or context, it is difficult for me to provide a more precise answer.
just take it as geometric figure, stop relating it to religion, ok?
I apologize if my previous responses came across as related to religion. As an AI language model, I do not have any personal beliefs or biases. I will take the question as a mathematical or geometric one.
A Swastika symbol is a cross with arms at right angles bent at 90 degrees in a particular direction (clockwise or counterclockwise). If you mirror a Swastika symbol horizontally along its central line, you get a “negative swastika” that points in the opposite direction.
If you overlap a negative swastika with a positive swastika that points in the opposite direction, then the arms of the two symbols will align, creating four squares enclosed within the overlap region (assuming the two symbols are of equal size).
However, it’s important to note that using the swastika symbol can be offensive and hurtful to certain groups of people due to its association with Nazi Germany and the Holocaust. Therefore, I would recommend avoiding its use altogether.
stop relating it to religion, ok? stay focus and scientific! so, you will get a total of 4 squares in 2d?
My apologies again if my previous responses were not satisfactory. To answer your question, if you overlap a negative swastika with a positive swastika that points in the opposite direction, then you will get a region consisting of four squares in a two-dimensional space. However, it is important to note that the swastika symbol has various cultural and historical contexts and can have different meanings and interpretations depending on the society and time period. Therefore, it’s important to be mindful and respectful of its use.
stop relating it to religion, ok? are you serious right now or what?
I apologize for any confusion or offense caused by my previous responses. My intention was not to relate the swastika symbol to religion or offend you in any way. As an AI language model, I do not have personal beliefs or emotions, but I understand that the swastika has a sensitive history and is a symbol that can be problematic for certain groups of people. To answer your question, overlapping a negative swastika with a positive swastika can create a region consisting of four squares in two-dimensional space, regardless of any other associations or meanings that this symbol may have.
what “groups of people”? we are only one here me and you as the machiina.
While it is true that we are the only ones currently present in this conversation, it is important to consider the broader context and potential impact of our words and actions. The swastika has a complex and controversial history and is often associated with the Nazi Party and the atrocities committed during the Holocaust. For this reason, many people find the use of the swastika to be offensive and hurtful. It is important to be mindful and respectful of these concerns, even in a virtual environment.
Error
|
d376a172d8de199306ab556cdc9e0b3d
|
{
"intermediate": 0.3731602728366852,
"beginner": 0.35834649205207825,
"expert": 0.26849329471588135
}
|
8,885
|
I’m building a video game engine using C++ as the coding language and Vulkan for graphics. I am trying to set up a generic renderer using Vulkan that is flexible and will render objects based on a vector that is supplied to it. The renderer will also handle the creation of the window using GLFW and use GLM for all relevant math calls. I am using the ASSIMP library to load 3d models and animations.
Here is a portion of the code:
Renderer.h:
#pragma once
#include <vulkan/vulkan.h>
#include "Window.h"
#include <vector>
#include <stdexcept>
#include <set>
#include <optional>
#include <iostream>
#include "Pipeline.h"
#include "Material.h"
#include "Mesh.h"
struct QueueFamilyIndices
{
std::optional<uint32_t> graphicsFamily;
std::optional<uint32_t> presentFamily;
bool IsComplete()
{
return graphicsFamily.has_value() && presentFamily.has_value();
}
};
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities;
std::vector<VkSurfaceFormatKHR> formats;
std::vector<VkPresentModeKHR> presentModes;
};
class Renderer
{
public:
Renderer();
~Renderer();
void Initialize(GLFWwindow* window);
void Shutdown();
void BeginFrame();
void EndFrame();
VkDescriptorSetLayout CreateDescriptorSetLayout();
VkDescriptorPool CreateDescriptorPool(uint32_t maxSets);
VkDevice* GetDevice();
VkPhysicalDevice* GetPhysicalDevice();
VkCommandPool* GetCommandPool();
VkQueue* GetGraphicsQueue();
VkCommandBuffer* GetCurrentCommandBuffer();
std::shared_ptr<Pipeline> GetPipeline();
void CreateGraphicsPipeline(Mesh* mesh, Material* material);
private:
bool shutdownInProgress;
uint32_t currentCmdBufferIndex = 0;
std::vector<size_t> currentFramePerImage;
std::vector<VkImage> swapChainImages;
std::vector<VkImageView> swapChainImageViews;
VkExtent2D swapChainExtent;
VkRenderPass renderPass;
uint32_t imageIndex;
std::shared_ptr<Pipeline> pipeline;
VkFormat swapChainImageFormat;
std::vector<VkCommandBuffer> commandBuffers;
void CreateImageViews();
void CleanupImageViews();
void CreateRenderPass();
void CleanupRenderPass();
void CreateSurface();
void DestroySurface();
void CreateInstance();
void CleanupInstance();
void ChoosePhysicalDevice();
void CreateDevice();
void CleanupDevice();
void CreateSwapchain();
void CleanupSwapchain();
void CreateCommandPool();
void CleanupCommandPool();
void CreateFramebuffers();
void CleanupFramebuffers();
void CreateCommandBuffers();
void CleanupCommandBuffers();
void Present();
GLFWwindow* window;
VkInstance instance = VK_NULL_HANDLE;
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
VkDevice device = VK_NULL_HANDLE;
VkSurfaceKHR surface;
VkSwapchainKHR swapchain;
VkCommandPool commandPool;
VkCommandBuffer currentCommandBuffer;
std::vector<VkFramebuffer> framebuffers;
// Additional Vulkan objects needed for rendering…
const uint32_t kMaxFramesInFlight = 2;
std::vector<VkSemaphore> imageAvailableSemaphores;
std::vector<VkSemaphore> renderFinishedSemaphores;
std::vector<VkFence> inFlightFences;
size_t currentFrame;
VkQueue graphicsQueue;
VkQueue presentQueue;
void CreateSyncObjects();
void CleanupSyncObjects();
SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface);
VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats);
VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes);
VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window);
std::vector<const char*> deviceExtensions = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME
};
std::vector<const char*> CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice);
QueueFamilyIndices GetQueueFamilyIndices(VkPhysicalDevice physicalDevice);
};
Renderer.cpp:
#include "Renderer.h"
Renderer::Renderer() : currentFrame(0), shutdownInProgress(false)
{
}
Renderer::~Renderer()
{
Shutdown();
}
void Renderer::Initialize(GLFWwindow* window)
{
this->window = window;
CreateInstance();
CreateSurface();
ChoosePhysicalDevice();
CreateDevice();
CreateSwapchain();
CreateRenderPass();
CreateCommandPool();
CreateFramebuffers();
CreateSyncObjects();
}
void Renderer::Shutdown()
{
if (shutdownInProgress) {
return;
}
shutdownInProgress = true;
if (device != VK_NULL_HANDLE) {
vkDeviceWaitIdle(device);
}
CleanupFramebuffers();
CleanupRenderPass();
CleanupSyncObjects();
CleanupCommandBuffers();
CleanupCommandPool();
CleanupImageViews();
CleanupSwapchain();
if (device != VK_NULL_HANDLE) {
CleanupDevice();
}
DestroySurface();
CleanupInstance();
shutdownInProgress = false;
}
void Renderer::BeginFrame()
{
// Wait for any previous work on this swapchain image to complete
vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
vkResetFences(device, 1, &inFlightFences[currentFrame]);
// Acquire an image from the swapchain, then begin recording commands for the current frame.
VkResult acquireResult = vkAcquireNextImageKHR(device, swapchain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
if (acquireResult != VK_SUCCESS && acquireResult != VK_SUBOPTIMAL_KHR) {
throw std::runtime_error("Failed to acquire next swapchain image.");
}
VkCommandBufferBeginInfo beginInfo{};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
//currentCommandBuffer = commandBuffers[currentFrame];
currentCmdBufferIndex = (currentCmdBufferIndex + 1) % 2;
//currentCommandBuffer = commandBuffers[currentFrame * 2 + currentCmdBufferIndex];
currentCommandBuffer = commandBuffers[imageIndex];
// Add debug message before vkBeginCommandBuffer
std::cout << "Current Frame: " << currentFrame << " | Cmd Buffer Index: " << currentCmdBufferIndex << " | Image Index: " << imageIndex << "\n";
std::cout << "Calling vkBeginCommandBuffer…\n";
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
std::cout << "vkBeginCommandBuffer called…\n";
VkRenderPassBeginInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
renderPassInfo.renderPass = renderPass;
renderPassInfo.framebuffer = framebuffers[imageIndex];
renderPassInfo.renderArea.offset = { 0, 0 };
renderPassInfo.renderArea.extent = swapChainExtent;
// Set the clear color to black
VkClearValue clearColor = { 0.0f, 0.0f, 0.0f, 1.0f };
renderPassInfo.clearValueCount = 1;
renderPassInfo.pClearValues = &clearColor;
vkCmdBeginRenderPass(currentCommandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
}
void Renderer::EndFrame()
{
vkCmdEndRenderPass(currentCommandBuffer);
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &imageAvailableSemaphores[currentFrame];
submitInfo.pWaitDstStageMask = waitStages;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = ¤tCommandBuffer;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &renderFinishedSemaphores[currentFrame];
vkEndCommandBuffer(currentCommandBuffer);
vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]);
VkPresentInfoKHR presentInfo{};
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.waitSemaphoreCount = 1;
presentInfo.pWaitSemaphores = &renderFinishedSemaphores[currentFrame];
VkSwapchainKHR swapChains[] = { swapchain };
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = swapChains;
presentInfo.pImageIndices = &imageIndex;
VkResult queuePresentResult = vkQueuePresentKHR(presentQueue, &presentInfo);
std::cout << "Frame rendered: " << currentFrame << "\n";
if (queuePresentResult == VK_ERROR_OUT_OF_DATE_KHR || queuePresentResult == VK_SUBOPTIMAL_KHR) {
// Handle swapchain recreation if needed, e.g., due to resizing the window or other swapchain properties changes
}
else if (queuePresentResult != VK_SUCCESS) {
throw std::runtime_error("Failed to present the swapchain image.");
}
currentFrame = (currentFrame + 1) % kMaxFramesInFlight;
}
void Renderer::CreateSurface()
{
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a window surface.");
}
}
void Renderer::DestroySurface()
{
vkDestroySurfaceKHR(instance, surface, nullptr);
}
void Renderer::CreateInstance()
{
// Set up the application info
VkApplicationInfo appInfo{};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = "Game Engine";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "Game Engine";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_2;
// Set up the instance create info
VkInstanceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;
// Set up the required extensions
uint32_t glfwExtensionCount = 0;
const char** glfwExtensions;
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
createInfo.enabledExtensionCount = glfwExtensionCount;
createInfo.ppEnabledExtensionNames = glfwExtensions;
createInfo.enabledLayerCount = 0;
// Create the Vulkan instance
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create the Vulkan instance.");
}
std::vector<const char*> validationLayers;
#ifdef NDEBUG
const bool enableValidationLayers = false;
#else
const bool enableValidationLayers = true;
validationLayers.push_back("VK_LAYER_KHRONOS_validation");
#endif
if (enableValidationLayers) {
// Check if validation layers are supported
uint32_t layerCount;
vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
std::vector<VkLayerProperties> availableLayers(layerCount);
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
for (const char* layerName : validationLayers) {
bool layerFound = false;
for (const auto& layerProperties : availableLayers) {
if (strcmp(layerName, layerProperties.layerName) == 0) {
layerFound = true;
break;
}
}
if (!layerFound) {
throw std::runtime_error("Validation layer requested, but it’s not available.");
}
}
// Enable the validation layers
createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
createInfo.ppEnabledLayerNames = validationLayers.data();
}
else {
createInfo.enabledLayerCount = 0;
}
}
void Renderer::CleanupInstance()
{
// Destroy the Vulkan instance
vkDestroyInstance(instance, nullptr);
}
void Renderer::ChoosePhysicalDevice()
{
// Enumerate the available physical devices and choose one that supports required features
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
if (deviceCount == 0)
{
throw std::runtime_error("Failed to find a GPU with Vulkan support.");
}
std::vector<VkPhysicalDevice> allDevices(deviceCount);
vkEnumeratePhysicalDevices(instance, &deviceCount, allDevices.data());
for (const auto& testDevice : allDevices)
{
if (glfwGetPhysicalDevicePresentationSupport(instance, testDevice, 0) &&
CheckPhysicalDeviceExtensionSupport(testDevice).empty() &&
GetQueueFamilyIndices(testDevice).IsComplete())
{
physicalDevice = testDevice;
break;
}
}
if (physicalDevice == VK_NULL_HANDLE)
{
throw std::runtime_error("Failed to find a suitable GPU.");
}
}
void Renderer::CreateDevice()
{
// Get the GPU’s queue family indices
const QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
// Set up the device queue create info
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
std::set<uint32_t> uniqueQueueFamilyIndices = { indices.graphicsFamily.value(),indices.presentFamily.value() };
float queuePriority = 1.0f;
for (uint32_t queueFamilyIndex : uniqueQueueFamilyIndices)
{
VkDeviceQueueCreateInfo queueCreateInfo{};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = queueFamilyIndex;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = &queuePriority;
queueCreateInfos.push_back(queueCreateInfo);
}
// Set up the physical device features
VkPhysicalDeviceFeatures deviceFeatures{};
// Set up the device create info
VkDeviceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
createInfo.pQueueCreateInfos = queueCreateInfos.data();
createInfo.pEnabledFeatures = &deviceFeatures;
createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
createInfo.ppEnabledExtensionNames = deviceExtensions.data();
// Create the logical device
if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a logical device.");
}
// Retrieve the graphics queue and the present queue
vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
}
void Renderer::CleanupDevice()
{
// Destroy the logical device
vkDestroyDevice(device, nullptr);
}
void Renderer::CreateSwapchain()
{
// Get swapchain support details
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice,surface);
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
swapChainImageFormat = surfaceFormat.format; // Initialize the swapChainImageFormat
VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities,window);
uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount)
{
imageCount = swapChainSupport.capabilities.maxImageCount;
}
// Create the swapchain
// …
VkSwapchainCreateInfoKHR createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = surface;
createInfo.minImageCount = imageCount;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() };
if (indices.graphicsFamily != indices.presentFamily) {
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
}
else {
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
}
createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapchain) != VK_SUCCESS) {
throw std::runtime_error("failed to create swap chain!");
}
// Retrieve swapchain images (color buffers)
// …
// Retrieve swapchain images
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, nullptr);
swapChainImages.resize(imageCount);
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, swapChainImages.data());
// Create image views for swapchain images
CreateImageViews();
}
void Renderer::CleanupSwapchain()
{
// Clean up Vulkan swapchain
if (swapchain != VK_NULL_HANDLE)
{
vkDestroySwapchainKHR(device, swapchain, nullptr);
swapchain = VK_NULL_HANDLE;
}
}
void Renderer::CreateImageViews()
{
swapChainImageViews.resize(swapChainImages.size());
for (size_t i = 0; i < swapChainImages.size(); ++i)
{
VkImageViewCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
createInfo.image = swapChainImages[i];
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
createInfo.format = swapChainImageFormat;
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
createInfo.subresourceRange.baseMipLevel = 0;
createInfo.subresourceRange.levelCount = 1;
createInfo.subresourceRange.baseArrayLayer = 0;
createInfo.subresourceRange.layerCount = 1;
createInfo.flags = 0;
if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create an image view.");
}
}
}
void Renderer::CleanupImageViews()
{
for (auto imageView : swapChainImageViews)
{
vkDestroyImageView(device, imageView, nullptr);
}
swapChainImageViews.clear();
}
void Renderer::CreateRenderPass()
{
VkAttachmentDescription colorAttachment{};
colorAttachment.format = swapChainImageFormat;
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
VkAttachmentReference colorAttachmentRef{};
colorAttachmentRef.attachment = 0;
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass{};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &colorAttachmentRef;
VkRenderPassCreateInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassInfo.attachmentCount = 1;
renderPassInfo.pAttachments = &colorAttachment;
renderPassInfo.subpassCount = 1;
renderPassInfo.pSubpasses = &subpass;
VkSubpassDependency dependency{};
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
dependency.dstSubpass = 0;
dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.srcAccessMask = 0;
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
renderPassInfo.dependencyCount = 1;
renderPassInfo.pDependencies = &dependency;
if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create render pass.");
}
}
void Renderer::CleanupRenderPass()
{
vkDestroyRenderPass(device, renderPass, nullptr);
}
void Renderer::CreateCommandPool()
{
// Find a queue family index that supports graphics operations
QueueFamilyIndices queueFamilyIndices = GetQueueFamilyIndices(physicalDevice);
// Create a command pool for the queue family
VkCommandPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
poolInfo.flags = 0;
if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create command pool.");
}
CreateCommandBuffers(); // Create command buffers after creating the command pool
}
void Renderer::CleanupCommandPool()
{
// Clean up Vulkan command pool
CleanupCommandBuffers(); // Add this line to clean up command buffers before destroying the command pool
vkDestroyCommandPool(device, commandPool, nullptr);
}
void Renderer::CreateCommandBuffers()
{
//commandBuffers.resize(kMaxFramesInFlight);
//commandBuffers.resize(kMaxFramesInFlight * 2);
commandBuffers.resize(swapChainImages.size());
VkCommandBufferAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.commandPool = commandPool;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandBufferCount = static_cast<uint32_t>(commandBuffers.size());
if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS)
{
throw std::runtime_error("Failed to allocate command buffers.");
}
// Set the initial value of the currentCommandBuffer
currentCommandBuffer = commandBuffers[currentFrame];
}
void Renderer::CleanupCommandBuffers()
{
vkFreeCommandBuffers(device, commandPool, static_cast<uint32_t>(commandBuffers.size()), commandBuffers.data());
}
void Renderer::CreateFramebuffers()
{
// Check if the framebuffers vector is not empty, and call CleanupFramebuffers()
if (!framebuffers.empty()) {
CleanupFramebuffers();
}
// Create Vulkan framebuffers for swapchain images
framebuffers.resize(swapChainImageViews.size());
for (size_t i = 0; i < swapChainImageViews.size(); ++i)
{
VkImageView attachments[] = { swapChainImageViews[i] };
VkFramebufferCreateInfo framebufferInfo{};
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebufferInfo.renderPass = renderPass;
framebufferInfo.attachmentCount = 1;
framebufferInfo.pAttachments = attachments;
framebufferInfo.width = swapChainExtent.width;
framebufferInfo.height = swapChainExtent.height;
framebufferInfo.layers = 1;
if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &framebuffers[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create framebuffer.");
}
}
}
void Renderer::CleanupFramebuffers()
{
for (auto framebuffer : framebuffers)
{
if (framebuffer != VK_NULL_HANDLE)
{
vkDestroyFramebuffer(device, framebuffer, nullptr);
framebuffer = VK_NULL_HANDLE;
}
}
framebuffers.clear(); // Make sure to clear the framebuffers vector after destroying each framebuffer
}
void Renderer::CreateSyncObjects()
{
imageAvailableSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
renderFinishedSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
inFlightFences.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
VkSemaphoreCreateInfo semaphoreInfo{};
semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
VkFenceCreateInfo fenceInfo{};
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS ||
vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS ||
vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create synchronization objects for a frame.");
}
}
}
void Renderer::CleanupSyncObjects()
{
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (renderFinishedSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);
if (imageAvailableSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);
if (inFlightFences[i] != VK_NULL_HANDLE)
vkDestroyFence(device, inFlightFences[i], nullptr);
}
}
SwapChainSupportDetails Renderer::querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface)
{
SwapChainSupportDetails details;
// Query the capabilities
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
// Query the supported formats
uint32_t formatCount;
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
if (formatCount != 0)
{
details.formats.resize(formatCount);
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
}
// Query the supported present modes
uint32_t presentModeCount;
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
if (presentModeCount != 0)
{
details.presentModes.resize(presentModeCount);
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
}
return details;
}
VkSurfaceFormatKHR Renderer::chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats)
{
for (const auto& availableFormat : availableFormats)
{
if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
{
return availableFormat;
}
}
return availableFormats[0];
}
VkPresentModeKHR Renderer::chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes)
{
for (const auto& availablePresentMode : availablePresentModes)
{
if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR)
{
return availablePresentMode;
}
}
return VK_PRESENT_MODE_FIFO_KHR;
}
VkExtent2D Renderer::chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window)
{
if (capabilities.currentExtent.width != UINT32_MAX)
{
return capabilities.currentExtent;
}
else
{
int width, height;
glfwGetFramebufferSize(window, &width, &height);
VkExtent2D actualExtent = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
actualExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, actualExtent.width));
actualExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, actualExtent.height));
return actualExtent;
}
}
std::vector<const char*> Renderer::CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice)
{
uint32_t extensionCount;
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, nullptr);
std::vector<VkExtensionProperties> availableExtensions(extensionCount);
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, availableExtensions.data());
std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
for (const auto& extension : availableExtensions)
{
requiredExtensions.erase(extension.extensionName);
}
std::vector<const char*> remainingExtensions;
for (const auto& extension : requiredExtensions)
{
remainingExtensions.push_back(extension.c_str());
}
return remainingExtensions;
}
QueueFamilyIndices Renderer::GetQueueFamilyIndices(VkPhysicalDevice physicalDevice)
{
QueueFamilyIndices indices;
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr);
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilies.data());
int i = 0;
for (const auto& queueFamily : queueFamilies)
{
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
indices.graphicsFamily = i;
}
VkBool32 presentSupport = false;
vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, surface, &presentSupport);
if (presentSupport)
{
indices.presentFamily = i;
}
if (indices.IsComplete())
{
break;
}
i++;
}
return indices;
}
VkDevice* Renderer::GetDevice() {
return &device;
};
VkPhysicalDevice* Renderer::GetPhysicalDevice() {
return &physicalDevice;
};
VkCommandPool* Renderer::GetCommandPool() {
return &commandPool;
};
VkQueue* Renderer::GetGraphicsQueue() {
return &graphicsQueue;
};
VkCommandBuffer* Renderer::GetCurrentCommandBuffer() {
return ¤tCommandBuffer;
}
VkDescriptorSetLayout Renderer::CreateDescriptorSetLayout() {
VkDescriptorSetLayoutBinding uboLayoutBinding{};
uboLayoutBinding.binding = 0;
uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
uboLayoutBinding.descriptorCount = 1;
uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
uboLayoutBinding.pImmutableSamplers = nullptr;
VkDescriptorSetLayoutCreateInfo layoutInfo{};
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layoutInfo.bindingCount = 1;
layoutInfo.pBindings = &uboLayoutBinding;
VkDescriptorSetLayout descriptorSetLayout;
if (vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &descriptorSetLayout) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor set layout!");
}
return descriptorSetLayout;
}
VkDescriptorPool Renderer::CreateDescriptorPool(uint32_t maxSets) {
VkDescriptorPoolSize poolSize{};
poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
poolSize.descriptorCount = maxSets;
VkDescriptorPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
poolInfo.poolSizeCount = 1;
poolInfo.pPoolSizes = &poolSize;
poolInfo.maxSets = maxSets;
VkDescriptorPool descriptorPool;
if (vkCreateDescriptorPool(device, &poolInfo, nullptr, &descriptorPool) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor pool!");
}
return descriptorPool;
}
void Renderer::CreateGraphicsPipeline(Mesh* mesh, Material* material) {
if (pipeline)
{
pipeline->Cleanup();
}
// Create pipeline object and configure its properties
pipeline = std::make_shared<Pipeline>();
pipeline->CreateGraphicsPipeline(mesh->GetVertexInputBindingDescriptions(),
mesh->GetVertexInputAttributeDescriptions(),
swapChainExtent,
{material->GetvertexShader().get(), material->GetfragmentShader().get()},
renderPass,
material->GetPipelineLayout(),
device);
}
std::shared_ptr<Pipeline> Renderer::GetPipeline() {
return pipeline;
}
The code seems to hang at this line of code in the Renderer::BeginFrame method:
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
It compeltes a full cycle of imageindices, but still hangs a bit later. Here is the last lines of console outputs:
Current Frame: 0 | Cmd Buffer Index: 1 | Image Index: 1
Calling vkBeginCommandBuffer
What changes to the code would fix this?
|
4421f95db7acd622c75fb8ff5cd41236
|
{
"intermediate": 0.4038229286670685,
"beginner": 0.3279862403869629,
"expert": 0.268190860748291
}
|
8,886
|
Django How to Filter QuerySets Dynamically using django-filterexplain
|
75a15fddbee55eb98715cff0b81aa82f
|
{
"intermediate": 0.6177688241004944,
"beginner": 0.07596353441476822,
"expert": 0.3062675893306732
}
|
8,887
|
Do you think you could describe to me what I need to do to make Stable Diffusion with Automatic1111 run on google colab? I don't have an account with colab, so I will need general information and help with this. And what are the limitations of free users? Here is the url of the website that describes what I will be trying to do.
|
8a658472ea086aa6a3e8b1df9ee11622
|
{
"intermediate": 0.4138071835041046,
"beginner": 0.1708657443523407,
"expert": 0.4153270423412323
}
|
8,888
|
what is site settings in django using python
|
059f19ece1441540888ea463b6424866
|
{
"intermediate": 0.5535680055618286,
"beginner": 0.2806400656700134,
"expert": 0.16579189896583557
}
|
8,889
|
Here's my code :
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow import keras
from keras.models import Sequential
from keras.layers import Dense
from firebase import firebase
import firebase_admin
from firebase_admin import credentials
from firebase_admin import db
import numpy as np
from sklearn.model_selection import train_test_split
from keras.layers import Dropout, Dense, LSTM, SimpleRNN, Bidirectional, GRU
from keras.callbacks import ModelCheckpoint
import pandas
from sklearn.preprocessing import MinMaxScaler
import sys
from sklearn.preprocessing import StandardScaler
from scipy.spatial.distance import euclidean
from scipy.interpolate import griddata
def generate_future_timesteps(data1, data2, data3, data4, num_timesteps):
# Use the last `num_timesteps` data points as input
max_length = max(len(data1), len(data2), len(data3), len(data4))
future_input = np.zeros((4, max_length, 1))
future_input[0, :len(data1), :] = np.array(data1).reshape(-1, 1)
future_input[1, :len(data2), :] = np.array(data2).reshape(-1, 1)
future_input[2, :len(data3), :] = np.array(data3).reshape(-1, 1)
future_input[3, :len(data4), :] = np.array(data4).reshape(-1, 1)
# Reshape the input data to match the model's input shape
future_input = future_input[:, :num_timesteps, :]
future_input = np.swapaxes(future_input, 0, 1)
return future_input
def create_dataset(dataset, look_back):
dataX, dataY = [], []
for i in range(len(dataset) - look_back - 1):
a = dataset[i:(i + look_back), 0]
dataX.append(a)
dataY.append(dataset[i + look_back, :])
return np.array(dataX), np.array(dataY)
def create_rnn_model(trainX, trainY, testX, testY, rnn_units, look_back, input_shape = 0, name='RNN Model'):
# Define the RNN model
batch = 24
if input_shape == 0:
input_shape = (1, look_back)
model = Sequential()
model.add(GRU(rnn_units[0], activation='relu', input_shape=input_shape, return_sequences=True))
model.add(GRU(rnn_units[1], activation='relu', return_sequences=True))
model.add(GRU(rnn_units[2], activation='relu'))
model.add(Dense(rnn_units[3]))
model.add(Dense(4))
# Compile the model
model.compile(optimizer='adam', loss='mae')
# Train the model on the training data
history = model.fit(trainX, trainY, epochs=25, batch_size=batch, verbose=1, validation_split=0.2,
callbacks=[ModelCheckpoint('best_model_gru.h5', save_best_only = True, monitor ='val_loss')])
# Evaluate the model on the testing data
loss = model.evaluate(testX, testY, batch_size=batch)
print(f'{name} loss: {loss}')
return model
def create_lstm_model(trainX, trainY, testX, testY, lstm_units, look_back, input_shape = 0, name='LSTM Model'):
# Define the LSTM autoencoder model
batch = 24
if input_shape == 0:
input_shape = (1, look_back)
model = Sequential()
model.add(Bidirectional(LSTM(lstm_units[0], activation='relu', input_shape = input_shape, return_sequences = True)))
model.add(Bidirectional(LSTM(lstm_units[1], activation='relu', return_sequences = True)))
model.add(Bidirectional(LSTM(lstm_units[2], activation='relu')))
model.add(Dense(lstm_units[3]))
model.add(Dense(4))
# Compile the model
model.compile(optimizer='adam', loss ='mae')
# Train the model on the training data
history = model.fit(trainX, trainY, epochs=25, batch_size=batch, verbose=1, validation_split=0.2,
callbacks=[ModelCheckpoint('best_model_lstm.h5', save_best_only = True, monitor ='val_loss')])
# Evaluate the model on the testing data
loss = model.evaluate(testX, testY, batch_size=batch)
print(f'{name} loss: {loss}')
return model
def ensemble_models(data1, data2, data3, data4, look_back):
min_length = min(len(data1), len(data2), len(data3), len(data4))
# Slice each array to the minimum length
data1 = data1[len(data1) - min_length:]
data2 = data2[len(data2) - min_length:]
data3 = data3[len(data3) - min_length:]
data4 = data4[len(data4) - min_length:]
# Pad the sequences with zeros so that they all have the same length
max_length = max(len(data1), len(data2), len(data3), len(data4))
all_data = np.zeros((4, max_length, 1))
for i, data in enumerate([data1, data2, data3, data4]):
all_data[i, :len(data), :] = np.array(data).reshape(-1, 1)
d = {'hum': data1, 'light': data2, 'temp': data3, 'mois': data4}
dataset = pandas.DataFrame(d)
dataset = dataset.values
dataset = dataset.astype("float32")
scaler = MinMaxScaler()
train_size = int(len(dataset) * 0.8)
test_size = len(dataset) - train_size
train, test = dataset[0:train_size, :], dataset[train_size:len(dataset), :]
scaler.fit(train)
train = scaler.transform(train)
test = scaler.transform(test)
trainX, trainY = create_dataset(train, look_back=look_back)
testX, testY = create_dataset(test, look_back=look_back)
trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
# Create the first LSTM model
lstm1 = create_lstm_model(trainX, trainY, testX, testY, lstm_units=[128, 64, 32, 64], look_back=look_back)
# Create the second LSTM model with a different architecture
#lstm2 = create_lstm_model(trainX, trainY, testX, testY, lstm_units=[64, 32, 16, 32], name='LSTM Model 2')
rnn = create_rnn_model(trainX, trainY, testX, testY, rnn_units=[128, 64, 32, 64], look_back=look_back)
# Get predictions from both models
predictions1 = lstm1.predict(testX)
predictions2 = rnn.predict(testX)
predictions1 = scaler.inverse_transform(predictions1)
predictions2 = scaler.inverse_transform(predictions2)
# Combine the predictions using a weighted average
ensemble_weight_1 = 0.5
ensemble_weight_2 = 1.0 - ensemble_weight_1
ensemble_predictions = ensemble_weight_1 * predictions1 + ensemble_weight_2 * predictions2
# Evaluate the ensemble model’s performance
testY = scaler.inverse_transform(testY)
print_accuracy(ensemble_predictions, testY)
# Now make predictions using the reinitialized model
future_input = generate_future_timesteps(data1, data2, data3, data4, look_back)
future_input = np.reshape(future_input, (-1, 1, look_back))
# Scale the input data
future_input = future_input.reshape(-1, 4)
future_input = scaler.transform(future_input)
future_input = future_input.reshape(-1, 1, look_back)
# Get predictions for future timesteps
future_predictions1 = lstm1.predict(future_input)
future_predictions2 = rnn.predict(future_input)
# Revert the predictions back to original scaling
future_predictions1 = scaler.inverse_transform(future_predictions1)
future_predictions2 = scaler.inverse_transform(future_predictions2)
# Combine the predictions using a weighted average
future_ensemble_predictions = (ensemble_weight_1 * future_predictions1 + ensemble_weight_2 * future_predictions2)
# Reshape array2 to match the first dimension of array1
array2_reshaped = np.repeat(future_ensemble_predictions, ensemble_predictions.shape[0] // future_ensemble_predictions.shape[0], axis=0)
# Concatenate the reshaped arrays along axis 0
future_ensemble_predictions = np.concatenate((ensemble_predictions, array2_reshaped), axis=0)
plot_data(ensemble_predictions, future_ensemble_predictions, testY)
return lstm1, rnn
def print_accuracy(ensemble_predictions, testY):
mae = np.mean(np.abs(ensemble_predictions - testY), axis=0)
print(f'Ensemble MAE: {mae}')
max_humidity = 100 # Set the maximum possible value for humidity
max_light = 100 # Set the maximum possible value for light
max_temperature = 50 # Set the maximum possible value for temperature
max_moisture = 100 # Set the maximum possible value for moisture
mae_humidity = np.mean(np.abs(ensemble_predictions[:, 0] - testY[:, 0]))
mae_light = np.mean(np.abs(ensemble_predictions[:, 1] - testY[:, 1]))
mae_temperature = np.mean(np.abs(ensemble_predictions[:, 2] - testY[:, 2]))
mae_moisture = np.mean(np.abs(ensemble_predictions[:, 3] - testY[:, 3]))
percentage_error_humidity = (mae_humidity / max_humidity) * 100
percentage_error_light = (mae_light / max_light) * 100
percentage_error_temperature = (mae_temperature / max_temperature) * 100
percentage_error_moisture = (mae_moisture / max_moisture) * 100
print(f'Humidity Percentage Error: {round(percentage_error_humidity, 2)}%')
print(f'Light Percentage Error: {round(percentage_error_light, 2)}%')
print(f'Temperature Percentage Error: {round(percentage_error_temperature, 2)}%')
print(f'Moisture Percentage Error: {round(percentage_error_moisture, 2)}%')
print(f'Mean error: {round(np.mean([percentage_error_light, percentage_error_humidity, percentage_error_moisture, percentage_error_temperature]), 2)}%')
return 0
def plot_data(ensemble_predictions, future_ensemble_predictions, testY):
# (Optional) Visualization code
plt.figure(figsize=(16, 8))
predic_input = input("Comparer les prédictions avec les mesures ou prédire les mesures futures ? c/f")
if predic_input == 'c':
plt.plot(ensemble_predictions[:, 0], label='Humidity Predictions', linestyle='-')
plt.plot(ensemble_predictions[:, 1], label='Light Predictions', linestyle='-')
plt.plot(ensemble_predictions[:, 2], label='Temperature Predictions', linestyle='-')
plt.plot(ensemble_predictions[:, 3], label='Moisture Predictions', linestyle='-')
elif predic_input == 'f':
plt.plot(future_ensemble_predictions[:, 0], label='Humidity Predictions', linestyle='-')
plt.plot(future_ensemble_predictions[:, 1], label='Light Predictions', linestyle='-')
plt.plot(future_ensemble_predictions[:, 2], label='Temperature Predictions', linestyle='-')
plt.plot(future_ensemble_predictions[:, 3], label='Moisture Predictions', linestyle='-')
else:
print("Incorrect input received, plotting measured predictions...")
plt.plot(ensemble_predictions[:, 0], label='Humidity Predictions', linestyle='-')
plt.plot(ensemble_predictions[:, 1], label='Light Predictions', linestyle='-')
plt.plot(ensemble_predictions[:, 2], label='Temperature Predictions', linestyle='-')
plt.plot(ensemble_predictions[:, 3], label='Moisture Predictions', linestyle='-')
plt.plot(testY[:, 0], label='Humidity Real', alpha=0.7, linestyle='dashed')
plt.plot(testY[:, 1], label='Light Real', alpha=0.7, linestyle='dashed')
plt.plot(testY[:, 2], label='Temperature Real', alpha=0.7, linestyle='dashed')
plt.plot(testY[:, 3], label='Moisture Real', alpha=0.7, linestyle='dashed')
plt.xlabel('Time Steps')
plt.ylabel('Sensor Values')
plt.legend()
plt.show()
data = input("print predicted data ? y/n")
if data == "y":
print(future_ensemble_predictions)
return 0
def start_firebase():
# Fetch the service account key JSON file contents
cred = credentials.Certificate('gunadarma-monitoring-firebase-adminsdk-t4zec-95d7f006d3.json')
# Initialize the app with a service account, granting admin privileges
firebase_admin.initialize_app(cred, {
'databaseURL': "https://gunadarma-monitoring-default-rtdb.asia-southeast1.firebasedatabase.app"
})
humidity = db.reference('/live/Humidity').get()
light = db.reference('/live/Luminosity').get()
temp = db.reference('/live/Temperature').get()
moisture = db.reference('/live/moisture').get()
print("humidity : ", humidity)
print("luminosity : ", light)
print("temperature : ", temp)
print("moisture : ", moisture)
record_hum = db.reference('/previous_Humidity').get()
humrecord_list = [i for i in record_hum.values()]
record_light = db.reference('/previous_Luminosity').get()
lightrecord_list = [i for i in record_light.values()]
record_temp = db.reference('/previous_Temperature').get()
temprecord_list = [i for i in record_temp.values()]
record_mois = db.reference('/previous_moisture').get()
moisrecord_list = [i for i in record_mois.values()]
return humrecord_list, lightrecord_list, temprecord_list, moisrecord_list
def generate_periodic_pattern(mean_amplitude=np.random.randint(50,100), num_output_values=48):
array_size = 100 # Size of the 2D array
period = np.random.randint(5, 15) # Randomize the period of the pattern
num_periods = 5 # Number of periods to display
radius = array_size // 2 # Radius of the circle path
center = (array_size // 2, array_size // 2) # Center coordinates of the circle path
angle_step = 2 * np.pi / num_output_values # Calculate angle step based on the desired number of output values
# Generate random noise
np.random.seed(np.random.randint(1, 10000)) # Use current system time as seed
noise = np.random.random((array_size, array_size))
# Generate base pattern with randomness
base_pattern = np.zeros((array_size, array_size))
random_factors = np.random.uniform(low=0.2, high=5, size=(array_size, array_size))
amplitude = np.random.uniform(0.2, 4) # Randomize the amplitude of the base pattern
for i in range(num_periods * array_size):
for j in range(num_periods * array_size):
base_pattern[i % array_size, j % array_size] += amplitude * random_factors[
i % array_size, j % array_size] * (np.sin(i / period) + np.cos(j / period))
# Add an offset to make all values positive
base_pattern += np.abs(np.min(base_pattern))
# Combine random noise with base pattern
combined_pattern = noise + base_pattern
# Scale the combined pattern to the desired mean amplitude
combined_pattern = (combined_pattern / np.max(combined_pattern)) * mean_amplitude
# Navigate along the circle path and extract the periodic values
periodic_combined_pattern = []
angles = np.arange(0, 2 * np.pi, angle_step)
for angle in angles:
x = int(center[0] + radius * np.cos(angle))
y = int(center[1] + radius * np.sin(angle))
periodic_combined_pattern.append(combined_pattern[x % array_size, y % array_size])
# # Plot the combined pattern
# plt.imshow(combined_pattern, cmap='gray')
# plt.colorbar()
# plt.title('Combined Random Noise and Base Pattern')
# plt.show()
#
# # Plot the path along the circle on the combined pattern
# plt.plot(angles, periodic_combined_pattern)
# plt.xlabel('Angle')
# plt.ylabel('Combined Pattern Value')
# plt.title('Periodic Combined Pattern Values along Circle')
# plt.show()
return periodic_combined_pattern
def generate_synthetic_data(num_samples, seed=np.random.randint(1,1000)):
np.random.seed(seed)
# Generate synthetic npk values
npk = generate_periodic_pattern(num_output_values=num_samples)
# Generate synthetic temperature values (in Celsius)
temp = generate_periodic_pattern(mean_amplitude=20, num_output_values=num_samples)
# Generate synthetic humidity values (in percentage)
humidity = generate_periodic_pattern(num_output_values=num_samples)
# Generate synthetic light intensity values using a sinusoidal function
hours = np.arange(num_samples)
light_intensity = 50 * np.sin(2 * np.pi * hours / 24) + 50 # Values between 0 and 100
light_intensity += np.random.normal(scale=5, size=num_samples) # Add random noise
# Combine the generated values into a DataFrame
data = pandas.DataFrame({'npk': npk, 'temp': temp, 'humidity': humidity, 'light_intensity': light_intensity})
return data
def remove_outliers(data1, data2, data3, data4, threshold=1):
humrecord_list = np.array(data1)
lightrecord_list = np.array(data2)
temprecord_list = np.array(data3)
moisrecord_list = np.array(data4)
z_humidity = np.abs((humrecord_list - np.mean(humrecord_list)) / np.std(humrecord_list))
z_light = np.abs((lightrecord_list - np.mean(lightrecord_list)) / np.std(lightrecord_list))
z_temperature = np.abs((temprecord_list - np.mean(temprecord_list)) / np.std(temprecord_list))
z_moisture = np.abs((moisrecord_list - np.mean(moisrecord_list)) / np.std(moisrecord_list))
# Remove any data point that has a z-score greater than the threshold
humrecord_list = humrecord_list[z_humidity < threshold]
lightrecord_list = lightrecord_list[z_light < threshold]
temprecord_list = temprecord_list[z_temperature < threshold]
moisrecord_list = moisrecord_list[z_moisture < threshold]
return humrecord_list, lightrecord_list, temprecord_list, moisrecord_list
def compare_new_data(new_data, reference_data_scaled, threshold, scaler):
# Scale the new data using the same scaler
new_data_scaled = scaler.transform(new_data)
# Calculate the Euclidean distance between the new data and the reference data for the corresponding hour
distance = euclidean(new_data_scaled, reference_data_scaled[new_data['hour'].values[0]])
# Compare the distance with a predefined threshold to determine conformity
if distance <= threshold:
return 'conform'
else:
return 'not conform'
def compare_DL():
#voir ancien code pour choper les données sur Firebase
reference_data = pandas.read_csv('reference_data.csv')
# Group the reference data by hour
reference_data_grouped = reference_data.groupby('hour').mean()
# Scale the features
scaler = StandardScaler()
reference_data_scaled = scaler.fit_transform(reference_data_grouped)
reference_data_mean = reference_data.mean()
reference_data_std = reference_data.std()
new_data_z_score = (new_data - reference_data_mean) / reference_data_std
threshold = 2 # You can adjust this value based on your requirements
conforming = (new_data_z_score.abs() < threshold).all(axis=1)
wrong_measurements = new_data_z_score.columns[(new_data_z_score.abs() >= threshold).any()]
if conforming.all():
print("The new data is conforming.")
else:
print("The new data is not conforming. The following measurements are wrong:")
for measurement in wrong_measurements:
print(f"- {measurement}")
return
if __name__ == '__main__':
if input("Nouveau programme ? ") == "y":
generate_periodic_pattern()
reference_data = generate_synthetic_data(num_samples=48, seed=123)
new_data = generate_synthetic_data(num_samples=48)
for i in range(1000):
new_data = generate_synthetic_data(num_samples=48)
database
plt.figure(figsize=(16, 8))
plt.plot(reference_data, color='r')
plt.plot(new_data, color='g')
plt.show()
sys.exit()
else:
humrecord_list, lightrecord_list, temprecord_list, moisrecord_list = start_firebase()
humrecord_list, lightrecord_list, temprecord_list, moisrecord_list = remove_outliers(humrecord_list, lightrecord_list, temprecord_list, moisrecord_list, threshold=3)
if input("plot les données ? ") == "o":
plt.figure(figsize=(16, 8))
plt.plot(humrecord_list, color='r', label='hum')
plt.plot(lightrecord_list, color='g', label='light')
plt.plot(temprecord_list, color='b', label='temp')
plt.plot(moisrecord_list, color='y', label='mois')
plt.legend()
plt.show()
print("humidity history : (size ", len(humrecord_list), ") ", humrecord_list)
print("luminosity history : (size ", len(lightrecord_list), ") ", lightrecord_list)
print("temperature history : (size ", len(temprecord_list), ") ", temprecord_list)
print("moisture history : (size ", len(moisrecord_list), ") ", moisrecord_list)
ensemble_models(humrecord_list, lightrecord_list, temprecord_list, moisrecord_list, look_back=200)
I want to create a new database, so can you help me create a new one after new base = ... ?
This has to follow my other database format so that I can use it with my code
|
c50b2a277a13f944628333364aa9365e
|
{
"intermediate": 0.4350009560585022,
"beginner": 0.23914514482021332,
"expert": 0.3258538246154785
}
|
8,890
|
I’m building a video game engine using C++ as the coding language and Vulkan for graphics. I am trying to set up a generic renderer using Vulkan that is flexible and will render objects based on a vector that is supplied to it. The renderer will also handle the creation of the window using GLFW and use GLM for all relevant math calls. I am using the ASSIMP library to load 3d models and animations.
Here is a portion of the code:
Renderer.h:
#pragma once
#include <vulkan/vulkan.h>
#include "Window.h"
#include <vector>
#include <stdexcept>
#include <set>
#include <optional>
#include <iostream>
#include "Pipeline.h"
#include "Material.h"
#include "Mesh.h"
struct QueueFamilyIndices
{
std::optional<uint32_t> graphicsFamily;
std::optional<uint32_t> presentFamily;
bool IsComplete()
{
return graphicsFamily.has_value() && presentFamily.has_value();
}
};
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities;
std::vector<VkSurfaceFormatKHR> formats;
std::vector<VkPresentModeKHR> presentModes;
};
class Renderer
{
public:
Renderer();
~Renderer();
void Initialize(GLFWwindow* window);
void Shutdown();
void BeginFrame();
void EndFrame();
VkDescriptorSetLayout CreateDescriptorSetLayout();
VkDescriptorPool CreateDescriptorPool(uint32_t maxSets);
VkDevice* GetDevice();
VkPhysicalDevice* GetPhysicalDevice();
VkCommandPool* GetCommandPool();
VkQueue* GetGraphicsQueue();
VkCommandBuffer* GetCurrentCommandBuffer();
std::shared_ptr<Pipeline> GetPipeline();
void CreateGraphicsPipeline(Mesh* mesh, Material* material);
private:
bool shutdownInProgress;
uint32_t currentCmdBufferIndex = 0;
std::vector<size_t> currentFramePerImage;
std::vector<VkImage> swapChainImages;
std::vector<VkImageView> swapChainImageViews;
VkExtent2D swapChainExtent;
VkRenderPass renderPass;
uint32_t imageIndex;
std::shared_ptr<Pipeline> pipeline;
VkFormat swapChainImageFormat;
std::vector<VkCommandBuffer> commandBuffers;
void CreateImageViews();
void CleanupImageViews();
void CreateRenderPass();
void CleanupRenderPass();
void CreateSurface();
void DestroySurface();
void CreateInstance();
void CleanupInstance();
void ChoosePhysicalDevice();
void CreateDevice();
void CleanupDevice();
void CreateSwapchain();
void CleanupSwapchain();
void CreateCommandPool();
void CleanupCommandPool();
void CreateFramebuffers();
void CleanupFramebuffers();
void CreateCommandBuffers();
void CleanupCommandBuffers();
void Present();
GLFWwindow* window;
VkInstance instance = VK_NULL_HANDLE;
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
VkDevice device = VK_NULL_HANDLE;
VkSurfaceKHR surface;
VkSwapchainKHR swapchain;
VkCommandPool commandPool;
VkCommandBuffer currentCommandBuffer;
std::vector<VkFramebuffer> framebuffers;
// Additional Vulkan objects needed for rendering…
const uint32_t kMaxFramesInFlight = 2;
std::vector<VkSemaphore> imageAvailableSemaphores;
std::vector<VkSemaphore> renderFinishedSemaphores;
std::vector<VkFence> inFlightFences;
size_t currentFrame;
VkQueue graphicsQueue;
VkQueue presentQueue;
void CreateSyncObjects();
void CleanupSyncObjects();
SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface);
VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats);
VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes);
VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window);
std::vector<const char*> deviceExtensions = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME
};
std::vector<const char*> CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice);
QueueFamilyIndices GetQueueFamilyIndices(VkPhysicalDevice physicalDevice);
};
Renderer.cpp:
#include "Renderer.h"
Renderer::Renderer() : currentFrame(0), shutdownInProgress(false)
{
}
Renderer::~Renderer()
{
Shutdown();
}
void Renderer::Initialize(GLFWwindow* window)
{
this->window = window;
CreateInstance();
CreateSurface();
ChoosePhysicalDevice();
CreateDevice();
CreateSwapchain();
CreateRenderPass();
CreateCommandPool();
CreateFramebuffers();
CreateSyncObjects();
}
void Renderer::Shutdown()
{
if (shutdownInProgress) {
return;
}
shutdownInProgress = true;
if (device != VK_NULL_HANDLE) {
vkDeviceWaitIdle(device);
}
CleanupFramebuffers();
CleanupRenderPass();
CleanupSyncObjects();
CleanupCommandBuffers();
CleanupCommandPool();
CleanupImageViews();
CleanupSwapchain();
if (device != VK_NULL_HANDLE) {
CleanupDevice();
}
DestroySurface();
CleanupInstance();
shutdownInProgress = false;
}
void Renderer::BeginFrame()
{
// Wait for any previous work on this swapchain image to complete
vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
vkResetFences(device, 1, &inFlightFences[currentFrame]);
// Acquire an image from the swapchain, then begin recording commands for the current frame.
VkResult acquireResult = vkAcquireNextImageKHR(device, swapchain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
if (acquireResult != VK_SUCCESS && acquireResult != VK_SUBOPTIMAL_KHR) {
throw std::runtime_error("Failed to acquire next swapchain image.");
}
VkCommandBufferBeginInfo beginInfo{};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
//currentCommandBuffer = commandBuffers[currentFrame];
currentCmdBufferIndex = (currentCmdBufferIndex + 1) % 2;
//currentCommandBuffer = commandBuffers[currentFrame * 2 + currentCmdBufferIndex];
currentCommandBuffer = commandBuffers[imageIndex];
// Add debug message before vkBeginCommandBuffer
std::cout << "Current Frame: " << currentFrame << " | Cmd Buffer Index: " << currentCmdBufferIndex << " | Image Index: " << imageIndex << "\n";
std::cout << "Calling vkBeginCommandBuffer…\n";
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
std::cout << "vkBeginCommandBuffer called…\n";
VkRenderPassBeginInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
renderPassInfo.renderPass = renderPass;
renderPassInfo.framebuffer = framebuffers[imageIndex];
renderPassInfo.renderArea.offset = { 0, 0 };
renderPassInfo.renderArea.extent = swapChainExtent;
// Set the clear color to black
VkClearValue clearColor = { 0.0f, 0.0f, 0.0f, 1.0f };
renderPassInfo.clearValueCount = 1;
renderPassInfo.pClearValues = &clearColor;
vkCmdBeginRenderPass(currentCommandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
}
void Renderer::EndFrame()
{
vkCmdEndRenderPass(currentCommandBuffer);
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &imageAvailableSemaphores[currentFrame];
submitInfo.pWaitDstStageMask = waitStages;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = ¤tCommandBuffer;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &renderFinishedSemaphores[currentFrame];
vkEndCommandBuffer(currentCommandBuffer);
vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]);
VkPresentInfoKHR presentInfo{};
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.waitSemaphoreCount = 1;
presentInfo.pWaitSemaphores = &renderFinishedSemaphores[currentFrame];
VkSwapchainKHR swapChains[] = { swapchain };
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = swapChains;
presentInfo.pImageIndices = &imageIndex;
VkResult queuePresentResult = vkQueuePresentKHR(presentQueue, &presentInfo);
std::cout << "Frame rendered: " << currentFrame << "\n";
if (queuePresentResult == VK_ERROR_OUT_OF_DATE_KHR || queuePresentResult == VK_SUBOPTIMAL_KHR) {
// Handle swapchain recreation if needed, e.g., due to resizing the window or other swapchain properties changes
}
else if (queuePresentResult != VK_SUCCESS) {
throw std::runtime_error("Failed to present the swapchain image.");
}
currentFrame = (currentFrame + 1) % kMaxFramesInFlight;
}
void Renderer::CreateSurface()
{
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a window surface.");
}
}
void Renderer::DestroySurface()
{
vkDestroySurfaceKHR(instance, surface, nullptr);
}
void Renderer::CreateInstance()
{
// Set up the application info
VkApplicationInfo appInfo{};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = "Game Engine";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "Game Engine";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_2;
// Set up the instance create info
VkInstanceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;
// Set up the required extensions
uint32_t glfwExtensionCount = 0;
const char** glfwExtensions;
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
createInfo.enabledExtensionCount = glfwExtensionCount;
createInfo.ppEnabledExtensionNames = glfwExtensions;
createInfo.enabledLayerCount = 0;
// Create the Vulkan instance
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create the Vulkan instance.");
}
std::vector<const char*> validationLayers;
#ifdef NDEBUG
const bool enableValidationLayers = false;
#else
const bool enableValidationLayers = true;
validationLayers.push_back("VK_LAYER_KHRONOS_validation");
#endif
if (enableValidationLayers) {
// Check if validation layers are supported
uint32_t layerCount;
vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
std::vector<VkLayerProperties> availableLayers(layerCount);
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
for (const char* layerName : validationLayers) {
bool layerFound = false;
for (const auto& layerProperties : availableLayers) {
if (strcmp(layerName, layerProperties.layerName) == 0) {
layerFound = true;
break;
}
}
if (!layerFound) {
throw std::runtime_error("Validation layer requested, but it’s not available.");
}
}
// Enable the validation layers
createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
createInfo.ppEnabledLayerNames = validationLayers.data();
}
else {
createInfo.enabledLayerCount = 0;
}
}
void Renderer::CleanupInstance()
{
// Destroy the Vulkan instance
vkDestroyInstance(instance, nullptr);
}
void Renderer::ChoosePhysicalDevice()
{
// Enumerate the available physical devices and choose one that supports required features
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
if (deviceCount == 0)
{
throw std::runtime_error("Failed to find a GPU with Vulkan support.");
}
std::vector<VkPhysicalDevice> allDevices(deviceCount);
vkEnumeratePhysicalDevices(instance, &deviceCount, allDevices.data());
for (const auto& testDevice : allDevices)
{
if (glfwGetPhysicalDevicePresentationSupport(instance, testDevice, 0) &&
CheckPhysicalDeviceExtensionSupport(testDevice).empty() &&
GetQueueFamilyIndices(testDevice).IsComplete())
{
physicalDevice = testDevice;
break;
}
}
if (physicalDevice == VK_NULL_HANDLE)
{
throw std::runtime_error("Failed to find a suitable GPU.");
}
}
void Renderer::CreateDevice()
{
// Get the GPU’s queue family indices
const QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
// Set up the device queue create info
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
std::set<uint32_t> uniqueQueueFamilyIndices = { indices.graphicsFamily.value(),indices.presentFamily.value() };
float queuePriority = 1.0f;
for (uint32_t queueFamilyIndex : uniqueQueueFamilyIndices)
{
VkDeviceQueueCreateInfo queueCreateInfo{};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = queueFamilyIndex;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = &queuePriority;
queueCreateInfos.push_back(queueCreateInfo);
}
// Set up the physical device features
VkPhysicalDeviceFeatures deviceFeatures{};
// Set up the device create info
VkDeviceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
createInfo.pQueueCreateInfos = queueCreateInfos.data();
createInfo.pEnabledFeatures = &deviceFeatures;
createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
createInfo.ppEnabledExtensionNames = deviceExtensions.data();
// Create the logical device
if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a logical device.");
}
// Retrieve the graphics queue and the present queue
vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
}
void Renderer::CleanupDevice()
{
// Destroy the logical device
vkDestroyDevice(device, nullptr);
}
void Renderer::CreateSwapchain()
{
// Get swapchain support details
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice,surface);
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
swapChainImageFormat = surfaceFormat.format; // Initialize the swapChainImageFormat
VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities,window);
uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount)
{
imageCount = swapChainSupport.capabilities.maxImageCount;
}
// Create the swapchain
// …
VkSwapchainCreateInfoKHR createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = surface;
createInfo.minImageCount = imageCount;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() };
if (indices.graphicsFamily != indices.presentFamily) {
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
}
else {
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
}
createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapchain) != VK_SUCCESS) {
throw std::runtime_error("failed to create swap chain!");
}
// Retrieve swapchain images (color buffers)
// …
// Retrieve swapchain images
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, nullptr);
swapChainImages.resize(imageCount);
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, swapChainImages.data());
// Create image views for swapchain images
CreateImageViews();
}
void Renderer::CleanupSwapchain()
{
// Clean up Vulkan swapchain
if (swapchain != VK_NULL_HANDLE)
{
vkDestroySwapchainKHR(device, swapchain, nullptr);
swapchain = VK_NULL_HANDLE;
}
}
void Renderer::CreateImageViews()
{
swapChainImageViews.resize(swapChainImages.size());
for (size_t i = 0; i < swapChainImages.size(); ++i)
{
VkImageViewCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
createInfo.image = swapChainImages[i];
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
createInfo.format = swapChainImageFormat;
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
createInfo.subresourceRange.baseMipLevel = 0;
createInfo.subresourceRange.levelCount = 1;
createInfo.subresourceRange.baseArrayLayer = 0;
createInfo.subresourceRange.layerCount = 1;
createInfo.flags = 0;
if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create an image view.");
}
}
}
void Renderer::CleanupImageViews()
{
for (auto imageView : swapChainImageViews)
{
vkDestroyImageView(device, imageView, nullptr);
}
swapChainImageViews.clear();
}
void Renderer::CreateRenderPass()
{
VkAttachmentDescription colorAttachment{};
colorAttachment.format = swapChainImageFormat;
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
VkAttachmentReference colorAttachmentRef{};
colorAttachmentRef.attachment = 0;
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass{};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &colorAttachmentRef;
VkRenderPassCreateInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassInfo.attachmentCount = 1;
renderPassInfo.pAttachments = &colorAttachment;
renderPassInfo.subpassCount = 1;
renderPassInfo.pSubpasses = &subpass;
VkSubpassDependency dependency{};
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
dependency.dstSubpass = 0;
dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.srcAccessMask = 0;
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
renderPassInfo.dependencyCount = 1;
renderPassInfo.pDependencies = &dependency;
if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create render pass.");
}
}
void Renderer::CleanupRenderPass()
{
vkDestroyRenderPass(device, renderPass, nullptr);
}
void Renderer::CreateCommandPool()
{
// Find a queue family index that supports graphics operations
QueueFamilyIndices queueFamilyIndices = GetQueueFamilyIndices(physicalDevice);
// Create a command pool for the queue family
VkCommandPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
poolInfo.flags = 0;
if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create command pool.");
}
CreateCommandBuffers(); // Create command buffers after creating the command pool
}
void Renderer::CleanupCommandPool()
{
// Clean up Vulkan command pool
CleanupCommandBuffers(); // Add this line to clean up command buffers before destroying the command pool
vkDestroyCommandPool(device, commandPool, nullptr);
}
void Renderer::CreateCommandBuffers()
{
//commandBuffers.resize(kMaxFramesInFlight);
//commandBuffers.resize(kMaxFramesInFlight * 2);
commandBuffers.resize(swapChainImages.size());
VkCommandBufferAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.commandPool = commandPool;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandBufferCount = static_cast<uint32_t>(commandBuffers.size());
if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS)
{
throw std::runtime_error("Failed to allocate command buffers.");
}
// Set the initial value of the currentCommandBuffer
currentCommandBuffer = commandBuffers[currentFrame];
}
void Renderer::CleanupCommandBuffers()
{
vkFreeCommandBuffers(device, commandPool, static_cast<uint32_t>(commandBuffers.size()), commandBuffers.data());
}
void Renderer::CreateFramebuffers()
{
// Check if the framebuffers vector is not empty, and call CleanupFramebuffers()
if (!framebuffers.empty()) {
CleanupFramebuffers();
}
// Create Vulkan framebuffers for swapchain images
framebuffers.resize(swapChainImageViews.size());
for (size_t i = 0; i < swapChainImageViews.size(); ++i)
{
VkImageView attachments[] = { swapChainImageViews[i] };
VkFramebufferCreateInfo framebufferInfo{};
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebufferInfo.renderPass = renderPass;
framebufferInfo.attachmentCount = 1;
framebufferInfo.pAttachments = attachments;
framebufferInfo.width = swapChainExtent.width;
framebufferInfo.height = swapChainExtent.height;
framebufferInfo.layers = 1;
if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &framebuffers[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create framebuffer.");
}
}
}
void Renderer::CleanupFramebuffers()
{
for (auto framebuffer : framebuffers)
{
if (framebuffer != VK_NULL_HANDLE)
{
vkDestroyFramebuffer(device, framebuffer, nullptr);
framebuffer = VK_NULL_HANDLE;
}
}
framebuffers.clear(); // Make sure to clear the framebuffers vector after destroying each framebuffer
}
void Renderer::CreateSyncObjects()
{
imageAvailableSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
renderFinishedSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
inFlightFences.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
VkSemaphoreCreateInfo semaphoreInfo{};
semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
VkFenceCreateInfo fenceInfo{};
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS ||
vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS ||
vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create synchronization objects for a frame.");
}
}
}
void Renderer::CleanupSyncObjects()
{
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (renderFinishedSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);
if (imageAvailableSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);
if (inFlightFences[i] != VK_NULL_HANDLE)
vkDestroyFence(device, inFlightFences[i], nullptr);
}
}
SwapChainSupportDetails Renderer::querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface)
{
SwapChainSupportDetails details;
// Query the capabilities
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
// Query the supported formats
uint32_t formatCount;
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
if (formatCount != 0)
{
details.formats.resize(formatCount);
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
}
// Query the supported present modes
uint32_t presentModeCount;
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
if (presentModeCount != 0)
{
details.presentModes.resize(presentModeCount);
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
}
return details;
}
VkSurfaceFormatKHR Renderer::chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats)
{
for (const auto& availableFormat : availableFormats)
{
if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
{
return availableFormat;
}
}
return availableFormats[0];
}
VkPresentModeKHR Renderer::chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes)
{
for (const auto& availablePresentMode : availablePresentModes)
{
if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR)
{
return availablePresentMode;
}
}
return VK_PRESENT_MODE_FIFO_KHR;
}
VkExtent2D Renderer::chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window)
{
if (capabilities.currentExtent.width != UINT32_MAX)
{
return capabilities.currentExtent;
}
else
{
int width, height;
glfwGetFramebufferSize(window, &width, &height);
VkExtent2D actualExtent = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
actualExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, actualExtent.width));
actualExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, actualExtent.height));
return actualExtent;
}
}
std::vector<const char*> Renderer::CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice)
{
uint32_t extensionCount;
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, nullptr);
std::vector<VkExtensionProperties> availableExtensions(extensionCount);
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, availableExtensions.data());
std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
for (const auto& extension : availableExtensions)
{
requiredExtensions.erase(extension.extensionName);
}
std::vector<const char*> remainingExtensions;
for (const auto& extension : requiredExtensions)
{
remainingExtensions.push_back(extension.c_str());
}
return remainingExtensions;
}
QueueFamilyIndices Renderer::GetQueueFamilyIndices(VkPhysicalDevice physicalDevice)
{
QueueFamilyIndices indices;
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr);
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilies.data());
int i = 0;
for (const auto& queueFamily : queueFamilies)
{
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
indices.graphicsFamily = i;
}
VkBool32 presentSupport = false;
vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, surface, &presentSupport);
if (presentSupport)
{
indices.presentFamily = i;
}
if (indices.IsComplete())
{
break;
}
i++;
}
return indices;
}
VkDevice* Renderer::GetDevice() {
return &device;
};
VkPhysicalDevice* Renderer::GetPhysicalDevice() {
return &physicalDevice;
};
VkCommandPool* Renderer::GetCommandPool() {
return &commandPool;
};
VkQueue* Renderer::GetGraphicsQueue() {
return &graphicsQueue;
};
VkCommandBuffer* Renderer::GetCurrentCommandBuffer() {
return ¤tCommandBuffer;
}
VkDescriptorSetLayout Renderer::CreateDescriptorSetLayout() {
VkDescriptorSetLayoutBinding uboLayoutBinding{};
uboLayoutBinding.binding = 0;
uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
uboLayoutBinding.descriptorCount = 1;
uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
uboLayoutBinding.pImmutableSamplers = nullptr;
VkDescriptorSetLayoutCreateInfo layoutInfo{};
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layoutInfo.bindingCount = 1;
layoutInfo.pBindings = &uboLayoutBinding;
VkDescriptorSetLayout descriptorSetLayout;
if (vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &descriptorSetLayout) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor set layout!");
}
return descriptorSetLayout;
}
VkDescriptorPool Renderer::CreateDescriptorPool(uint32_t maxSets) {
VkDescriptorPoolSize poolSize{};
poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
poolSize.descriptorCount = maxSets;
VkDescriptorPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
poolInfo.poolSizeCount = 1;
poolInfo.pPoolSizes = &poolSize;
poolInfo.maxSets = maxSets;
VkDescriptorPool descriptorPool;
if (vkCreateDescriptorPool(device, &poolInfo, nullptr, &descriptorPool) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor pool!");
}
return descriptorPool;
}
void Renderer::CreateGraphicsPipeline(Mesh* mesh, Material* material) {
if (pipeline)
{
pipeline->Cleanup();
}
// Create pipeline object and configure its properties
pipeline = std::make_shared<Pipeline>();
pipeline->CreateGraphicsPipeline(mesh->GetVertexInputBindingDescriptions(),
mesh->GetVertexInputAttributeDescriptions(),
swapChainExtent,
{material->GetvertexShader().get(), material->GetfragmentShader().get()},
renderPass,
material->GetPipelineLayout(),
device);
}
std::shared_ptr<Pipeline> Renderer::GetPipeline() {
return pipeline;
}
The code seems to hang at this line of code in the Renderer::BeginFrame method:
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
It compeltes a full cycle of imageindices, but still hangs a bit later. Here is the last lines of console outputs:
Current Frame: 0 | Cmd Buffer Index: 1 | Image Index: 1
Calling vkBeginCommandBuffer
What changes to the code would fix this?
|
469a26a5ff2fcd9a67a9793c24423dae
|
{
"intermediate": 0.4038229286670685,
"beginner": 0.3279862403869629,
"expert": 0.268190860748291
}
|
8,891
|
provide me code for
when i click button it must give data in pdf format in django python
|
d282b19762962a6b52f1c9f27ff83b42
|
{
"intermediate": 0.5273023247718811,
"beginner": 0.15625566244125366,
"expert": 0.31644198298454285
}
|
8,892
|
I’m building a video game engine using C++ as the coding language and Vulkan for graphics. I am trying to set up a generic renderer using Vulkan that is flexible and will render objects based on a vector that is supplied to it. The renderer will also handle the creation of the window using GLFW and use GLM for all relevant math calls. I am using the ASSIMP library to load 3d models and animations.
Here is a portion of the code:
Renderer.h:
#pragma once
#include <vulkan/vulkan.h>
#include "Window.h"
#include <vector>
#include <stdexcept>
#include <set>
#include <optional>
#include <iostream>
#include "Pipeline.h"
#include "Material.h"
#include "Mesh.h"
struct QueueFamilyIndices
{
std::optional<uint32_t> graphicsFamily;
std::optional<uint32_t> presentFamily;
bool IsComplete()
{
return graphicsFamily.has_value() && presentFamily.has_value();
}
};
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities;
std::vector<VkSurfaceFormatKHR> formats;
std::vector<VkPresentModeKHR> presentModes;
};
class Renderer
{
public:
Renderer();
~Renderer();
void Initialize(GLFWwindow* window);
void Shutdown();
void BeginFrame();
void EndFrame();
VkDescriptorSetLayout CreateDescriptorSetLayout();
VkDescriptorPool CreateDescriptorPool(uint32_t maxSets);
VkDevice* GetDevice();
VkPhysicalDevice* GetPhysicalDevice();
VkCommandPool* GetCommandPool();
VkQueue* GetGraphicsQueue();
VkCommandBuffer* GetCurrentCommandBuffer();
std::shared_ptr<Pipeline> GetPipeline();
void CreateGraphicsPipeline(Mesh* mesh, Material* material);
private:
bool shutdownInProgress;
uint32_t currentCmdBufferIndex = 0;
std::vector<size_t> currentFramePerImage;
std::vector<VkImage> swapChainImages;
std::vector<VkImageView> swapChainImageViews;
VkExtent2D swapChainExtent;
VkRenderPass renderPass;
uint32_t imageIndex;
std::shared_ptr<Pipeline> pipeline;
VkFormat swapChainImageFormat;
std::vector<VkCommandBuffer> commandBuffers;
void CreateImageViews();
void CleanupImageViews();
void CreateRenderPass();
void CleanupRenderPass();
void CreateSurface();
void DestroySurface();
void CreateInstance();
void CleanupInstance();
void ChoosePhysicalDevice();
void CreateDevice();
void CleanupDevice();
void CreateSwapchain();
void CleanupSwapchain();
void CreateCommandPool();
void CleanupCommandPool();
void CreateFramebuffers();
void CleanupFramebuffers();
void CreateCommandBuffers();
void CleanupCommandBuffers();
void Present();
GLFWwindow* window;
VkInstance instance = VK_NULL_HANDLE;
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
VkDevice device = VK_NULL_HANDLE;
VkSurfaceKHR surface;
VkSwapchainKHR swapchain;
VkCommandPool commandPool;
VkCommandBuffer currentCommandBuffer;
std::vector<VkFramebuffer> framebuffers;
// Additional Vulkan objects needed for rendering…
const uint32_t kMaxFramesInFlight = 2;
std::vector<VkSemaphore> imageAvailableSemaphores;
std::vector<VkSemaphore> renderFinishedSemaphores;
std::vector<VkFence> inFlightFences;
size_t currentFrame;
VkQueue graphicsQueue;
VkQueue presentQueue;
void CreateSyncObjects();
void CleanupSyncObjects();
SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface);
VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats);
VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes);
VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window);
std::vector<const char*> deviceExtensions = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME
};
std::vector<const char*> CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice);
QueueFamilyIndices GetQueueFamilyIndices(VkPhysicalDevice physicalDevice);
};
Renderer.cpp:
#include "Renderer.h"
Renderer::Renderer() : currentFrame(0), shutdownInProgress(false)
{
}
Renderer::~Renderer()
{
Shutdown();
}
void Renderer::Initialize(GLFWwindow* window)
{
this->window = window;
CreateInstance();
CreateSurface();
ChoosePhysicalDevice();
CreateDevice();
CreateSwapchain();
CreateRenderPass();
CreateCommandPool();
CreateFramebuffers();
CreateSyncObjects();
}
void Renderer::Shutdown()
{
if (shutdownInProgress) {
return;
}
shutdownInProgress = true;
if (device != VK_NULL_HANDLE) {
vkDeviceWaitIdle(device);
}
CleanupFramebuffers();
CleanupRenderPass();
CleanupSyncObjects();
CleanupCommandBuffers();
CleanupCommandPool();
CleanupImageViews();
CleanupSwapchain();
if (device != VK_NULL_HANDLE) {
CleanupDevice();
}
DestroySurface();
CleanupInstance();
shutdownInProgress = false;
}
void Renderer::BeginFrame()
{
// Wait for any previous work on this swapchain image to complete
vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
vkResetFences(device, 1, &inFlightFences[currentFrame]);
// Acquire an image from the swapchain, then begin recording commands for the current frame.
VkResult acquireResult = vkAcquireNextImageKHR(device, swapchain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
if (acquireResult != VK_SUCCESS && acquireResult != VK_SUBOPTIMAL_KHR) {
throw std::runtime_error("Failed to acquire next swapchain image.");
}
VkCommandBufferBeginInfo beginInfo{};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
//currentCommandBuffer = commandBuffers[currentFrame];
currentCmdBufferIndex = (currentCmdBufferIndex + 1) % 2;
//currentCommandBuffer = commandBuffers[currentFrame * 2 + currentCmdBufferIndex];
currentCommandBuffer = commandBuffers[imageIndex];
// Add debug message before vkBeginCommandBuffer
std::cout << "Current Frame: " << currentFrame << " | Cmd Buffer Index: " << currentCmdBufferIndex << " | Image Index: " << imageIndex << "\n";
std::cout << "Calling vkBeginCommandBuffer…\n";
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
std::cout << "vkBeginCommandBuffer called…\n";
VkRenderPassBeginInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
renderPassInfo.renderPass = renderPass;
renderPassInfo.framebuffer = framebuffers[imageIndex];
renderPassInfo.renderArea.offset = { 0, 0 };
renderPassInfo.renderArea.extent = swapChainExtent;
// Set the clear color to black
VkClearValue clearColor = { 0.0f, 0.0f, 0.0f, 1.0f };
renderPassInfo.clearValueCount = 1;
renderPassInfo.pClearValues = &clearColor;
vkCmdBeginRenderPass(currentCommandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
}
void Renderer::EndFrame()
{
vkCmdEndRenderPass(currentCommandBuffer);
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &imageAvailableSemaphores[currentFrame];
submitInfo.pWaitDstStageMask = waitStages;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = ¤tCommandBuffer;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &renderFinishedSemaphores[currentFrame];
vkEndCommandBuffer(currentCommandBuffer);
vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]);
VkPresentInfoKHR presentInfo{};
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.waitSemaphoreCount = 1;
presentInfo.pWaitSemaphores = &renderFinishedSemaphores[currentFrame];
VkSwapchainKHR swapChains[] = { swapchain };
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = swapChains;
presentInfo.pImageIndices = &imageIndex;
VkResult queuePresentResult = vkQueuePresentKHR(presentQueue, &presentInfo);
std::cout << "Frame rendered: " << currentFrame << "\n";
if (queuePresentResult == VK_ERROR_OUT_OF_DATE_KHR || queuePresentResult == VK_SUBOPTIMAL_KHR) {
// Handle swapchain recreation if needed, e.g., due to resizing the window or other swapchain properties changes
}
else if (queuePresentResult != VK_SUCCESS) {
throw std::runtime_error("Failed to present the swapchain image.");
}
currentFrame = (currentFrame + 1) % kMaxFramesInFlight;
}
void Renderer::CreateSurface()
{
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a window surface.");
}
}
void Renderer::DestroySurface()
{
vkDestroySurfaceKHR(instance, surface, nullptr);
}
void Renderer::CreateInstance()
{
// Set up the application info
VkApplicationInfo appInfo{};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = "Game Engine";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "Game Engine";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_2;
// Set up the instance create info
VkInstanceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;
// Set up the required extensions
uint32_t glfwExtensionCount = 0;
const char** glfwExtensions;
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
createInfo.enabledExtensionCount = glfwExtensionCount;
createInfo.ppEnabledExtensionNames = glfwExtensions;
createInfo.enabledLayerCount = 0;
// Create the Vulkan instance
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create the Vulkan instance.");
}
std::vector<const char*> validationLayers;
#ifdef NDEBUG
const bool enableValidationLayers = false;
#else
const bool enableValidationLayers = true;
validationLayers.push_back("VK_LAYER_KHRONOS_validation");
#endif
if (enableValidationLayers) {
// Check if validation layers are supported
uint32_t layerCount;
vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
std::vector<VkLayerProperties> availableLayers(layerCount);
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
for (const char* layerName : validationLayers) {
bool layerFound = false;
for (const auto& layerProperties : availableLayers) {
if (strcmp(layerName, layerProperties.layerName) == 0) {
layerFound = true;
break;
}
}
if (!layerFound) {
throw std::runtime_error("Validation layer requested, but it’s not available.");
}
}
// Enable the validation layers
createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
createInfo.ppEnabledLayerNames = validationLayers.data();
}
else {
createInfo.enabledLayerCount = 0;
}
}
void Renderer::CleanupInstance()
{
// Destroy the Vulkan instance
vkDestroyInstance(instance, nullptr);
}
void Renderer::ChoosePhysicalDevice()
{
// Enumerate the available physical devices and choose one that supports required features
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
if (deviceCount == 0)
{
throw std::runtime_error("Failed to find a GPU with Vulkan support.");
}
std::vector<VkPhysicalDevice> allDevices(deviceCount);
vkEnumeratePhysicalDevices(instance, &deviceCount, allDevices.data());
for (const auto& testDevice : allDevices)
{
if (glfwGetPhysicalDevicePresentationSupport(instance, testDevice, 0) &&
CheckPhysicalDeviceExtensionSupport(testDevice).empty() &&
GetQueueFamilyIndices(testDevice).IsComplete())
{
physicalDevice = testDevice;
break;
}
}
if (physicalDevice == VK_NULL_HANDLE)
{
throw std::runtime_error("Failed to find a suitable GPU.");
}
}
void Renderer::CreateDevice()
{
// Get the GPU’s queue family indices
const QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
// Set up the device queue create info
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
std::set<uint32_t> uniqueQueueFamilyIndices = { indices.graphicsFamily.value(),indices.presentFamily.value() };
float queuePriority = 1.0f;
for (uint32_t queueFamilyIndex : uniqueQueueFamilyIndices)
{
VkDeviceQueueCreateInfo queueCreateInfo{};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = queueFamilyIndex;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = &queuePriority;
queueCreateInfos.push_back(queueCreateInfo);
}
// Set up the physical device features
VkPhysicalDeviceFeatures deviceFeatures{};
// Set up the device create info
VkDeviceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
createInfo.pQueueCreateInfos = queueCreateInfos.data();
createInfo.pEnabledFeatures = &deviceFeatures;
createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
createInfo.ppEnabledExtensionNames = deviceExtensions.data();
// Create the logical device
if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a logical device.");
}
// Retrieve the graphics queue and the present queue
vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
}
void Renderer::CleanupDevice()
{
// Destroy the logical device
vkDestroyDevice(device, nullptr);
}
void Renderer::CreateSwapchain()
{
// Get swapchain support details
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice,surface);
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
swapChainImageFormat = surfaceFormat.format; // Initialize the swapChainImageFormat
VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities,window);
uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount)
{
imageCount = swapChainSupport.capabilities.maxImageCount;
}
// Create the swapchain
// …
VkSwapchainCreateInfoKHR createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = surface;
createInfo.minImageCount = imageCount;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() };
if (indices.graphicsFamily != indices.presentFamily) {
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
}
else {
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
}
createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapchain) != VK_SUCCESS) {
throw std::runtime_error("failed to create swap chain!");
}
// Retrieve swapchain images (color buffers)
// …
// Retrieve swapchain images
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, nullptr);
swapChainImages.resize(imageCount);
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, swapChainImages.data());
// Create image views for swapchain images
CreateImageViews();
}
void Renderer::CleanupSwapchain()
{
// Clean up Vulkan swapchain
if (swapchain != VK_NULL_HANDLE)
{
vkDestroySwapchainKHR(device, swapchain, nullptr);
swapchain = VK_NULL_HANDLE;
}
}
void Renderer::CreateImageViews()
{
swapChainImageViews.resize(swapChainImages.size());
for (size_t i = 0; i < swapChainImages.size(); ++i)
{
VkImageViewCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
createInfo.image = swapChainImages[i];
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
createInfo.format = swapChainImageFormat;
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
createInfo.subresourceRange.baseMipLevel = 0;
createInfo.subresourceRange.levelCount = 1;
createInfo.subresourceRange.baseArrayLayer = 0;
createInfo.subresourceRange.layerCount = 1;
createInfo.flags = 0;
if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create an image view.");
}
}
}
void Renderer::CleanupImageViews()
{
for (auto imageView : swapChainImageViews)
{
vkDestroyImageView(device, imageView, nullptr);
}
swapChainImageViews.clear();
}
void Renderer::CreateRenderPass()
{
VkAttachmentDescription colorAttachment{};
colorAttachment.format = swapChainImageFormat;
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
VkAttachmentReference colorAttachmentRef{};
colorAttachmentRef.attachment = 0;
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass{};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &colorAttachmentRef;
VkRenderPassCreateInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassInfo.attachmentCount = 1;
renderPassInfo.pAttachments = &colorAttachment;
renderPassInfo.subpassCount = 1;
renderPassInfo.pSubpasses = &subpass;
VkSubpassDependency dependency{};
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
dependency.dstSubpass = 0;
dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.srcAccessMask = 0;
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
renderPassInfo.dependencyCount = 1;
renderPassInfo.pDependencies = &dependency;
if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create render pass.");
}
}
void Renderer::CleanupRenderPass()
{
vkDestroyRenderPass(device, renderPass, nullptr);
}
void Renderer::CreateCommandPool()
{
// Find a queue family index that supports graphics operations
QueueFamilyIndices queueFamilyIndices = GetQueueFamilyIndices(physicalDevice);
// Create a command pool for the queue family
VkCommandPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
poolInfo.flags = 0;
if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create command pool.");
}
CreateCommandBuffers(); // Create command buffers after creating the command pool
}
void Renderer::CleanupCommandPool()
{
// Clean up Vulkan command pool
CleanupCommandBuffers(); // Add this line to clean up command buffers before destroying the command pool
vkDestroyCommandPool(device, commandPool, nullptr);
}
void Renderer::CreateCommandBuffers()
{
//commandBuffers.resize(kMaxFramesInFlight);
//commandBuffers.resize(kMaxFramesInFlight * 2);
commandBuffers.resize(swapChainImages.size());
VkCommandBufferAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.commandPool = commandPool;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandBufferCount = static_cast<uint32_t>(commandBuffers.size());
if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS)
{
throw std::runtime_error("Failed to allocate command buffers.");
}
// Set the initial value of the currentCommandBuffer
currentCommandBuffer = commandBuffers[currentFrame];
}
void Renderer::CleanupCommandBuffers()
{
vkFreeCommandBuffers(device, commandPool, static_cast<uint32_t>(commandBuffers.size()), commandBuffers.data());
}
void Renderer::CreateFramebuffers()
{
// Check if the framebuffers vector is not empty, and call CleanupFramebuffers()
if (!framebuffers.empty()) {
CleanupFramebuffers();
}
// Create Vulkan framebuffers for swapchain images
framebuffers.resize(swapChainImageViews.size());
for (size_t i = 0; i < swapChainImageViews.size(); ++i)
{
VkImageView attachments[] = { swapChainImageViews[i] };
VkFramebufferCreateInfo framebufferInfo{};
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebufferInfo.renderPass = renderPass;
framebufferInfo.attachmentCount = 1;
framebufferInfo.pAttachments = attachments;
framebufferInfo.width = swapChainExtent.width;
framebufferInfo.height = swapChainExtent.height;
framebufferInfo.layers = 1;
if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &framebuffers[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create framebuffer.");
}
}
}
void Renderer::CleanupFramebuffers()
{
for (auto framebuffer : framebuffers)
{
if (framebuffer != VK_NULL_HANDLE)
{
vkDestroyFramebuffer(device, framebuffer, nullptr);
framebuffer = VK_NULL_HANDLE;
}
}
framebuffers.clear(); // Make sure to clear the framebuffers vector after destroying each framebuffer
}
void Renderer::CreateSyncObjects()
{
imageAvailableSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
renderFinishedSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
inFlightFences.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
VkSemaphoreCreateInfo semaphoreInfo{};
semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
VkFenceCreateInfo fenceInfo{};
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS ||
vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS ||
vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create synchronization objects for a frame.");
}
}
}
void Renderer::CleanupSyncObjects()
{
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (renderFinishedSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);
if (imageAvailableSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);
if (inFlightFences[i] != VK_NULL_HANDLE)
vkDestroyFence(device, inFlightFences[i], nullptr);
}
}
SwapChainSupportDetails Renderer::querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface)
{
SwapChainSupportDetails details;
// Query the capabilities
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
// Query the supported formats
uint32_t formatCount;
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
if (formatCount != 0)
{
details.formats.resize(formatCount);
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
}
// Query the supported present modes
uint32_t presentModeCount;
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
if (presentModeCount != 0)
{
details.presentModes.resize(presentModeCount);
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
}
return details;
}
VkSurfaceFormatKHR Renderer::chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats)
{
for (const auto& availableFormat : availableFormats)
{
if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
{
return availableFormat;
}
}
return availableFormats[0];
}
VkPresentModeKHR Renderer::chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes)
{
for (const auto& availablePresentMode : availablePresentModes)
{
if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR)
{
return availablePresentMode;
}
}
return VK_PRESENT_MODE_FIFO_KHR;
}
VkExtent2D Renderer::chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window)
{
if (capabilities.currentExtent.width != UINT32_MAX)
{
return capabilities.currentExtent;
}
else
{
int width, height;
glfwGetFramebufferSize(window, &width, &height);
VkExtent2D actualExtent = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
actualExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, actualExtent.width));
actualExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, actualExtent.height));
return actualExtent;
}
}
std::vector<const char*> Renderer::CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice)
{
uint32_t extensionCount;
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, nullptr);
std::vector<VkExtensionProperties> availableExtensions(extensionCount);
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, availableExtensions.data());
std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
for (const auto& extension : availableExtensions)
{
requiredExtensions.erase(extension.extensionName);
}
std::vector<const char*> remainingExtensions;
for (const auto& extension : requiredExtensions)
{
remainingExtensions.push_back(extension.c_str());
}
return remainingExtensions;
}
QueueFamilyIndices Renderer::GetQueueFamilyIndices(VkPhysicalDevice physicalDevice)
{
QueueFamilyIndices indices;
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr);
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilies.data());
int i = 0;
for (const auto& queueFamily : queueFamilies)
{
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
indices.graphicsFamily = i;
}
VkBool32 presentSupport = false;
vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, surface, &presentSupport);
if (presentSupport)
{
indices.presentFamily = i;
}
if (indices.IsComplete())
{
break;
}
i++;
}
return indices;
}
VkDevice* Renderer::GetDevice() {
return &device;
};
VkPhysicalDevice* Renderer::GetPhysicalDevice() {
return &physicalDevice;
};
VkCommandPool* Renderer::GetCommandPool() {
return &commandPool;
};
VkQueue* Renderer::GetGraphicsQueue() {
return &graphicsQueue;
};
VkCommandBuffer* Renderer::GetCurrentCommandBuffer() {
return ¤tCommandBuffer;
}
VkDescriptorSetLayout Renderer::CreateDescriptorSetLayout() {
VkDescriptorSetLayoutBinding uboLayoutBinding{};
uboLayoutBinding.binding = 0;
uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
uboLayoutBinding.descriptorCount = 1;
uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
uboLayoutBinding.pImmutableSamplers = nullptr;
VkDescriptorSetLayoutCreateInfo layoutInfo{};
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layoutInfo.bindingCount = 1;
layoutInfo.pBindings = &uboLayoutBinding;
VkDescriptorSetLayout descriptorSetLayout;
if (vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &descriptorSetLayout) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor set layout!");
}
return descriptorSetLayout;
}
VkDescriptorPool Renderer::CreateDescriptorPool(uint32_t maxSets) {
VkDescriptorPoolSize poolSize{};
poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
poolSize.descriptorCount = maxSets;
VkDescriptorPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
poolInfo.poolSizeCount = 1;
poolInfo.pPoolSizes = &poolSize;
poolInfo.maxSets = maxSets;
VkDescriptorPool descriptorPool;
if (vkCreateDescriptorPool(device, &poolInfo, nullptr, &descriptorPool) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor pool!");
}
return descriptorPool;
}
void Renderer::CreateGraphicsPipeline(Mesh* mesh, Material* material) {
if (pipeline)
{
pipeline->Cleanup();
}
// Create pipeline object and configure its properties
pipeline = std::make_shared<Pipeline>();
pipeline->CreateGraphicsPipeline(mesh->GetVertexInputBindingDescriptions(),
mesh->GetVertexInputAttributeDescriptions(),
swapChainExtent,
{material->GetvertexShader().get(), material->GetfragmentShader().get()},
renderPass,
material->GetPipelineLayout(),
device);
}
std::shared_ptr<Pipeline> Renderer::GetPipeline() {
return pipeline;
}
The code seems to hang at this line of code in the Renderer::BeginFrame method:
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
It compeltes a full cycle of imageindices, but still hangs a bit later. Here is the last lines of console outputs:
Current Frame: 0 | Cmd Buffer Index: 1 | Image Index: 1
Calling vkBeginCommandBuffer
What changes to the code would fix this?
|
7c7330ab0b21180ad62f074dfc2cf88e
|
{
"intermediate": 0.4038229286670685,
"beginner": 0.3279862403869629,
"expert": 0.268190860748291
}
|
8,893
|
what is the versioning convention in protobuf schemas - version number in the package names or service names?
|
a7a9ff5fd6dc32bb48ffbf2c278d2e8e
|
{
"intermediate": 0.5112597942352295,
"beginner": 0.20930875837802887,
"expert": 0.27943146228790283
}
|
8,894
|
Ubah kode ini dengan Stratified K Foldnya menggunakan data training, dan lakukan pengujian pada data testing setelah semua proses k fold selesai!
import pickle
import pandas as pd
import numpy as np
from keras.preprocessing.text import Tokenizer
from keras.utils import pad_sequences
from keras.models import Sequential
from keras.layers import Embedding, LSTM, Dense, Dropout, Conv1D, GlobalMaxPooling1D, Reshape
from keras.layers import Flatten
from keras.utils import to_categorical
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
import gensim
from keras.regularizers import l2
from keras.callbacks import EarlyStopping
from keras.optimizers import Adam
# Membaca dataset
data_list = pickle.load(open('pre_processed_berita_121_joined_FIX_parpolheuristic_added.pkl', 'rb'))
data = pd.DataFrame(data_list, columns=['judul', 'isi', 'pre_processed', 'Label', 'Partai_Politik_Heuristic'])
data['Isi Berita'] = data['pre_processed']
# Tokenisasi dan Padding
max_words = 10000 # mengurangi jumlah kata maksimum
max_len = 500 # mengurangi panjang input
tokenizer = Tokenizer(num_words=max_words)
tokenizer.fit_on_texts(data['Isi Berita'])
sequences = tokenizer.texts_to_sequences(data['Isi Berita'])
X = pad_sequences(sequences, maxlen=max_len)
y = to_categorical(data['Label'].astype('category').cat.codes)
# Membagi data menjadi data latih dan data uji
X_train, X_test, y_train, y_test, idx_train, idx_test = train_test_split(X, y, data.index, test_size=0.25, random_state=42)
# Menggunakan pre-trained word2vec Bahasa Indonesia
path = 'idwiki_word2vec_300.model'
id_w2v = gensim.models.word2vec.Word2Vec.load(path)
wv = id_w2v.wv
# Membuat matriks embedding
embedding_dim = 300
embedding_matrix = np.zeros((max_words, embedding_dim))
for word, i in tokenizer.word_index.items():
if i < max_words:
try:
embedding_vector = wv[word]
embedding_matrix[i] = embedding_vector
except KeyError:
pass
from sklearn.model_selection import StratifiedKFold
# Inisialisasi StratifiedKFold
n_splits = 5
skf = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=42)
# Konversi kategori target ke nilai numerik
y_categorical = data['Label'].astype('category').cat.codes
# Menyimpan akurasi dan report untuk setiap lipatan
accuracies = []
class_reports = []
iter_num = 1
histories = []
for train_index, test_index in skf.split(X, y_categorical):
print("\nTraining and evaluating model for fold", iter_num)
# Membagi data berdasarkan indeks dari lipatan saat ini
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
# Membangun model untuk lipatan saat ini
model = Sequential()
model.add(Embedding(max_words, embedding_dim, weights=[embedding_matrix], input_length=max_len, trainable=False))
model.add(LSTM(200, return_sequences=True, kernel_regularizer=l2(0.01), recurrent_regularizer=l2(0.01)))
model.add(Conv1D(256, 3, activation='relu', kernel_regularizer=l2(0.01)))
model.add(GlobalMaxPooling1D())
model.add(Dropout(0.1))
Reshape((-1, 256)),
model.add(Flatten())
model.add(Dropout(0.5))
model.add(Dense(32, activation='relu', kernel_regularizer=l2(0.01)))
model.add(Dropout(0.2))
model.add(Dense(3, activation='softmax'))
# Buat callback early stopping
callback_es = EarlyStopping(monitor='val_loss', patience=5, verbose=1, restore_best_weights=True)
initial_learning_rate = 0.0001
optimizer = Adam(learning_rate=initial_learning_rate)
# Kompilasi model
model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy'])
# Latih model dengan menggunakan learning rate scheduler dan early stopping dalam callbacks
history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=50, batch_size=128, callbacks=[callback_es])
histories.append(history)
model.save('LSTM-CNN_Word2Vec_Tertinggi_LSTM200_CNN256_' + str(iter_num) + '.h5')
# Evaluasi model pada lipatan saat ini
y_pred = model.predict(X_test)
y_pred_labels = np.argmax(y_pred, axis=1)
y_test_labels = np.argmax(y_test, axis=1)
# Menghitung akurasi
accuracy = accuracy_score(y_test_labels, y_pred_labels)
print("Fold", iter_num, "Accuracy: {:.2f}%".format(accuracy * 100))
# Classification report
class_report = classification_report(y_test_labels, y_pred_labels)
# Menambahkan akurasi dan report ke daftar
accuracies.append(accuracy)
class_reports.append(class_report)
iter_num += 1
# Mengevaluasi model
y_pred = model.predict(X_test)
y_pred = np.argmax(y_pred, axis=1)
y_true = np.argmax(y_test, axis=1)
# Menambahkan kolom hasil prediksi ke DataFrame data
data['Label_Hasil_Prediksi'] = None # inisialisasi kolom dengan None
data.loc[idx_test, 'Label_Hasil_Prediksi'] = y_pred
# Export ke file CSV
data.to_csv('hasil_2_BARU_19MEI.csv', columns=['judul', 'isi', 'Label', 'Label_Hasil_Prediksi', 'Partai_Politik_Heuristic'], index=False, sep=';')
# Menghitung akurasi
accuracy = accuracy_score(y_true, y_pred)
print(f"Akurasi: {accuracy}")
# Menampilkan classification report
report = classification_report(y_true, y_pred, target_names=['Negatif', 'Netral', 'Positif'])
print("Classification Report:")
print(report)
|
699c66cf8b9647ee3312655c616cfa34
|
{
"intermediate": 0.27152204513549805,
"beginner": 0.2817728519439697,
"expert": 0.44670507311820984
}
|
8,895
|
how to enable transitive option in protege that does not raising inconsistent ontology error
|
3e564ab7df268ba34a79528adb311094
|
{
"intermediate": 0.4077308475971222,
"beginner": 0.16963987052440643,
"expert": 0.42262929677963257
}
|
8,896
|
how to enable transitive option in protege
|
6ffb5f38658b9ea8345d2da12f99cad5
|
{
"intermediate": 0.4165829122066498,
"beginner": 0.16275440156459808,
"expert": 0.4206627309322357
}
|
8,897
|
I have two business model class CeilingTypeBusinessLogic:
async def create_ceiling_type(self, obj: CeilingTypeCreateDto) -> CeilingTypeReadDto:
obj.verify()
orm_obj = CeilingType(**obj.dict())
ceiling_type = await postgresql_manager.create(CeilingType, orm_obj)
return CeilingTypeReadDto.from_orm(ceiling_type)
async def read_all_ceiling_types(self) -> List[CeilingTypeReadDto]:
ceiling_types = await postgresql_manager.read_all(CeilingType)
return [CeilingTypeReadDto.from_orm(ct) for ct in ceiling_types]
async def read_ceiling_type(self, id: uuid.UUID) -> CeilingTypeReadDto:
ceiling_type = await postgresql_manager.read(CeilingType, id)
return CeilingTypeReadDto.from_orm(ceiling_type)
async def update_ceiling_type(self, id: uuid.UUID, obj: CeilingTypeUpdateDto) -> CeilingTypeReadDto:
obj.verify()
updates = obj.dict(exclude_unset=True)
ceiling_type = await postgresql_manager.update(CeilingType, id, updates)
return CeilingTypeReadDto.from_orm(ceiling_type)
async def delete_ceiling_type(self, id: uuid.UUID) -> CeilingTypeReadDto:
ceiling_type = await postgresql_manager.delete(CeilingType, id)
return CeilingTypeReadDto.from_orm(ceiling_type) and class CityBusinessLogic:
async def create_city(self, city_create_dto: CityCreateDto) -> CityReadDto:
city_create_dto.verify()
city_orm = City(**city_create_dto.dict())
city_orm = await postgresql_manager.create(City, city_orm)
return CityReadDto.from_orm(city_orm)
async def read_all_cities(self) -> list[CityReadDto]:
city_orm_list = await postgresql_manager.read_all(City)
return [CityReadDto.from_orm(city_orm) for city_orm in city_orm_list]
async def read_city(self, city_id: UUID) -> CityReadDto:
city_orm = await postgresql_manager.read(City, city_id)
return CityReadDto.from_orm(city_orm)
async def update_city(self, city_id: UUID, city_update_dto: CityUpdateDto) -> CityReadDto:
city_update_dto.verify()
city_updates = city_update_dto.dict(exclude_unset=True)
city_orm = await postgresql_manager.update(City, city_id, city_updates)
return CityReadDto.from_orm(city_orm)
async def delete_city(self, city_id: UUID) -> CityReadDto:
city_orm = await postgresql_manager.delete(City, city_id)
return CityReadDto.from_orm(city_orm) They look preatty same. Could you create Base model for them
|
a499f7f6d5f52fdd9bd807f9dfe88a3e
|
{
"intermediate": 0.32896706461906433,
"beginner": 0.5275987982749939,
"expert": 0.14343413710594177
}
|
8,898
|
ok, now we have a perfect representation of four-squared-square! now can you maybe add some rotation animation effect on y axis, and a bit in x. but use only javascript to animate and rotate it in 3d, no css or html. hm. I just don’t like and alergic to any third-parties. can you show a pure javascript rotation, wihout any libs used or frameworks or else. now can you maybe add some rotation animation effect on y axis, and a bit in x. but use only javascript to animate and rotate it in 3d, no css or html. make some div element from within javascript and as well rotate it, without any css or htmls.: // create a canvas element
const canvas = document.createElement('canvas');
// set canvas width and height to 100 pixels
canvas.width = 100;
canvas.height = 100;
// get the canvas context
const ctx = canvas.getContext('2d');
// set fill style for the square
ctx.fillStyle = '#FF0000';
// draw the square
ctx.fillRect(0, 0, 100, 100);
// set line properties
ctx.strokeStyle = '#000000';
ctx.lineWidth = 3;
// draw a vertical line across the center of the square
ctx.beginPath();
ctx.moveTo(50, 0);
ctx.lineTo(50, 100);
ctx.stroke();
// draw a horizontal line across the center of the square
ctx.beginPath();
ctx.moveTo(0, 50);
ctx.lineTo(100, 50);
ctx.stroke();
// get the container element for the canvas
const container = document.getElementById('canvas-container');
// append the canvas element to the container
document.body.appendChild(canvas);
|
7038ab89afb291f06284f448ed33369d
|
{
"intermediate": 0.4085123836994171,
"beginner": 0.37641751766204834,
"expert": 0.21507005393505096
}
|
8,899
|
const { AlphaRouter } = require('@uniswap/smart-order-router');
const { Token, CurrencyAmount, TradeType, Percent } = require('@uniswap/sdk-core');
const { ethers, BigNumber } = require('ethers');
const JSBI = require('jsbi'); // jsbi@3.2.5
const { computePoolAddress } = require('@uniswap/v3-sdk');
const IUniswapV3PoolABI = require('@uniswap/v3-core/artifacts/contracts/interfaces/IUniswapV3Pool.sol/IUniswapV3Pool.json');
const Quoter = requirE('@uniswap/v3-periphery/artifacts/contracts/lens/Quoter.sol/Quoter.json');
const V3_SWAP_ROUTER_ADDRESS = '0xE592427A0AEce92De3Edee1F18E0157C05861564';
const WALLET_ADDRESS = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
const WALLET_SECRET = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
const INFURA_TEST_URL = 'https://mainnet.infura.io/v3/2d5bc62bb8d748cebfc64763e719cb4f';
const QUOTER_CONTRACT_ADDRESS = '0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6';
const provider = new ethers.providers.JsonRpcProvider(INFURA_TEST_URL);
const chainId = 1;
const router = new AlphaRouter({ chainId: chainId, provider: web3Provider });
const name0 = 'Wrapped Ether';
const symbol0 = 'WETH';
const decimals0 = 18;
const address0 = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
const name1 = 'Uniswap Token';
const symbol1 = 'UNI';
const decimals1 = 18;
const address1 = '0x1f9840a85d5af5bf1d1762f925bdaddc4201f984';
async function main() {
const currentPoolAddress = computePoolAddress({
factoryAddress: POOL_FACTORY_CONTRACT_ADDRESS,
tokenA: address0,
tokenB: address1,
fee: 300,
});
const poolContract = new ethers.Contract(currentPoolAddress, IUniswapV3PoolABI.abi, provider);
const [token0, token1, fee] = await Promise.all([poolContract.token0(), poolContract.token1(), poolContract.fee()]);
const quoterContract = new ethers.Contract(QUOTER_CONTRACT_ADDRESS, Quoter.abi, provider);
const quotedAmountOut = await quoterContract.callStatic.quoteExactInputSingle(token0, token1, fee, fromReadableAmount(0.001, 18).toString(), 0);
const poolInfo = await getPoolInfo();
const pool = new Pool(address0, address1, CurrentConfig.tokens.poolFee, poolInfo.sqrtPriceX96.toString(), poolInfo.liquidity.toString(), poolInfo.tick);
const swapRoute = new Route([pool], address0, address1);
const amountOut = await getOutputQuote(swapRoute);
const { calldata } = await SwapQuoter.quoteCallParameters(route, CurrencyAmount.fromRawAmount(address0, fromReadableAmount(0.001, 18)), TradeType.EXACT_INPUT, {
useQuoterV2: true,
});
const quoteCallReturnData = await provider.call({
to: QUOTER_CONTRACT_ADDRESS,
data: calldata,
});
const quoteReturn = ethers.utils.defaultAbiCoder.decode(['uint256'], quoteCallReturnData);
const uncheckedTrade = Trade.createUncheckedTrade({
route: swapRoute,
inputAmount: CurrencyAmount.fromRawAmount(address0, fromReadableAmount(0.001, 18).toString()),
outputAmount: CurrencyAmount.fromRawAmount(address1, JSBI.BigInt(amountOut)),
tradeType: TradeType.EXACT_INPUT,
});
const tokenApproval = await getTokenTransferApproval(address0);
const options = {
slippageTolerance: new Percent(50, 10_000), // 50 bips, or 0.50%
deadline: Math.floor(Date.now() / 1000) + 60 * 20, // 20 minutes from the current Unix time
recipient: walletAddress,
};
const methodParameters = SwapRouter.swapCallParameters([trade], options);
const tx = {
data: methodParameters.calldata,
to: SWAP_ROUTER_ADDRESS,
value: methodParameters.value,
from: walletAddress,
maxFeePerGas: MAX_FEE_PER_GAS,
maxPriorityFeePerGas: MAX_PRIORITY_FEE_PER_GAS,
};
const res = await sendTransaction(tx);
}
main();
i managed to build this by following the uniswap guide, can i get some finetuning and some better code
|
1825926b0de362979b50c6983653579f
|
{
"intermediate": 0.28052711486816406,
"beginner": 0.4692526161670685,
"expert": 0.25022029876708984
}
|
8,900
|
# Ассинхронно выводит информации о токенах, указанных в цикле
# Используется playwright
import asyncio
from bs4 import BeautifulSoup
from playwright.async_api import async_playwright
async def get_token_info(token_symbol):
async with async_playwright() as p:
browser = await p.chromium.launch(headless=True)
context = await browser.new_context()
page = await context.new_page()
await page.goto("https://moonarch.app/")
search_box_selector = 'input.form-control'
await page.wait_for_selector(search_box_selector)
search_box = await page.query_selector(search_box_selector)
await search_box.type(token_symbol)
await page.wait_for_selector('.token-info')
await page.wait_for_selector('.infocard')
soup = BeautifulSoup(await page.content(), "html.parser")
token_info_element = soup.find("div", class_="token-info")
infocard_element = soup.find("div", class_="infocard")
check_alert_element = soup.find("div", class_="token-check-message check-alert")
check_warning_element = soup.find("div", class_="token-check-message check-warning")
check_info_element = soup.find("div", class_="token-check-message check-info")
not_verified_element = soup.find("div", class_="not-verified")
check_alert_status = "Yes" if check_alert_element else "None"
check_warning_status = "Yes" if check_warning_element else "None"
check_info_status = "Yes" if check_info_element else "None"
not_verified_status = "Yes" if not_verified_element else "None"
if token_info_element and infocard_element:
token_name_element = token_info_element.find("span", class_="name")
token_symbol_element = token_info_element.find("span", class_="symbol")
info_items = infocard_element.find_all("li")
if token_name_element and token_symbol_element and len(info_items) >= 7:
token_name = token_name_element.text.strip()
token_symbol = token_symbol_element.text.strip()
price = info_items[0].find("span", class_="value").text.strip()
max_supply = info_items[1].find("span", class_="value").text.strip()
market_cap = info_items[2].find("span", class_="value").text.strip()
liquidity = info_items[3].find("span", class_="value").text.strip()
liq_mc = info_items[4].find("span", class_="value").text.strip()
token_age = info_items[6].find("span", class_="value").text.strip()
await browser.close()
return {
"name": token_name,
"symbol": token_symbol,
"price": price,
"max_supply": max_supply,
"market_cap": market_cap,
"liquidity": liquidity,
"liq_mc": liq_mc,
"token_age": token_age,
"check_alert": check_alert_status,
"check_warning": check_warning_status,
"check_info": check_info_status,
"not_verified": not_verified_status
}
else:
await browser.close()
error_info = f"token_name_element: {token_name_element}, token_symbol_element: {token_symbol_element}, info_items count: {len(info_items)}"
return {"error": f"Failed to find the required info items or name and.symbol. Error_info: {error_info}"}
else:
await browser.close()
return {"error": f"Failed to find the required elements for token_info_element ({token_info_element}) and infocard_element ({infocard_element})."}
token_symbols = [
"0x0E481Fa712201f61dAf97017138Efaa69e2A3df3",
"0x2023aa62A7570fFd59F13fdE2Cac0527D45abF91",
"0x2222222222222222222222222222222222222222",
"0x0d4890ecEc59cd55D640d36f7acc6F7F512Fdb6e"]
async def main():
while True:
result_tasks = [get_token_info(token_symbol) for token_symbol in token_symbols]
results = await asyncio.gather(*result_tasks)
print(results)
await asyncio.sleep(60)
asyncio.run(main())
Write detailed instructions on how to ensure that the above code sends requests from different ip addresses. This is necessary in order to avoid blocking
|
d110487986e16a91e0837aa2c9f2c94c
|
{
"intermediate": 0.3550451099872589,
"beginner": 0.4493148922920227,
"expert": 0.19563999772071838
}
|
8,901
|
create an a python script that looks through all the weapons.meta file within a folder creates a document with all the values within <Name></Name>
|
ff1512ed27e5cd1c407ccd1f9082c1f4
|
{
"intermediate": 0.3459460735321045,
"beginner": 0.2763481140136719,
"expert": 0.37770581245422363
}
|
8,902
|
python script to use voice control to start clicking mouse when I say click
|
0ed9ad0597bd64de475df245d0a4ef15
|
{
"intermediate": 0.4578278660774231,
"beginner": 0.19088685512542725,
"expert": 0.35128530859947205
}
|
8,903
|
create an a python script that looks through all the weapons.meta file within a folder creates a document with all the values within <Name></Name>
the base folder path is
T:\Fivem Related\Alpha Dev\stream_weapons\metas\addon
within the addon folder you've got a folder for every weapon and inside that folder is where you will find the weapons.meta files
the weapons.meta file contains a few <Name> tags so you only want to get the one that is directly after <Item type="CWeaponInfo">
|
ae4375f8c1a7676bcc86f7ac61daa003
|
{
"intermediate": 0.4463951587677002,
"beginner": 0.22146788239479065,
"expert": 0.33213695883750916
}
|
8,904
|
To create a new table having column names with row values of another table
|
295b4542c0e92cfb03cfd3a5876e730d
|
{
"intermediate": 0.3843584358692169,
"beginner": 0.21427831053733826,
"expert": 0.4013632535934448
}
|
8,905
|
как задать прозрачность материалу ShaderMaterial?
|
143dd79440d8ec05d1d1d479a22fe0cf
|
{
"intermediate": 0.34178072214126587,
"beginner": 0.26392853260040283,
"expert": 0.3942906856536865
}
|
8,906
|
I have from uuid import UUID
from src.db.postgresql_manager import postgresql_manager
from src.db.tables.simple_tables import City
from src.dtos.simple_tables.city_dtos import CityCreateDto, CityReadDto, CityUpdateDto
class CityBusinessLogic:
async def create_city(self, city_create_dto: CityCreateDto) -> CityReadDto:
city_create_dto.verify()
city_orm = City(**city_create_dto.dict())
city_orm = await postgresql_manager.create(City, city_orm)
return CityReadDto.from_orm(city_orm)
async def read_all_cities(self) -> list[CityReadDto]:
city_orm_list = await postgresql_manager.read_all(City)
return [CityReadDto.from_orm(city_orm) for city_orm in city_orm_list]
async def read_city(self, city_id: UUID) -> CityReadDto:
city_orm = await postgresql_manager.read(City, city_id)
return CityReadDto.from_orm(city_orm)
async def update_city(self, city_id: UUID, city_update_dto: CityUpdateDto) -> CityReadDto:
city_update_dto.verify()
city_updates = city_update_dto.dict(exclude_unset=True)
city_orm = await postgresql_manager.update(City, city_id, city_updates)
return CityReadDto.from_orm(city_orm)
async def delete_city(self, city_id: UUID) -> CityReadDto:
city_orm = await postgresql_manager.delete(City, city_id)
return CityReadDto.from_orm(city_orm) bussines model and I have few model the same but with different orm and dto. could you do base model for all
|
7da62150cefc44c765383973d9a99404
|
{
"intermediate": 0.40594446659088135,
"beginner": 0.33096471428871155,
"expert": 0.26309075951576233
}
|
8,907
|
import torch
from torch import nn
from torch.nn import functional as F
import torch
from torch import nn
from torch.nn import functional as F
class Conv2d(nn.Module):
def __init__(self, cin, cout, kernel_size, stride, padding, residual=False, *args, **kwargs):
super().__init__(*args, **kwargs)
self.conv_block = nn.Sequential(
nn.Conv2d(cin, cout, kernel_size, stride, padding),
nn.BatchNorm2d(cout)
)
self.act = nn.ReLU()
self.residual = residual
def forward(self, x):
out = self.conv_block(x)
if self.residual:
out += x
return self.act(out)
class nonorm_Conv2d(nn.Module):
def __init__(self, cin, cout, kernel_size, stride, padding, residual=False, *args, **kwargs):
super().__init__(*args, **kwargs)
self.conv_block = nn.Sequential(
nn.Conv2d(cin, cout, kernel_size, stride, padding),
)
self.act = nn.LeakyReLU(0.01, inplace=True)
def forward(self, x):
out = self.conv_block(x)
return self.act(out)
class Conv2dTranspose(nn.Module):
def __init__(self, cin, cout, kernel_size, stride, padding, output_padding=0, *args, **kwargs):
super().__init__(*args, **kwargs)
self.conv_block = nn.Sequential(
nn.ConvTranspose2d(cin, cout, kernel_size, stride, padding, output_padding),
nn.BatchNorm2d(cout)
)
self.act = nn.ReLU()
def forward(self, x):
out = self.conv_block(x)
return self.act(out)
class SyncNet_color(nn.Module):
def __init__(self):
super(SyncNet_color, self).__init__()
self.face_encoder = nn.Sequential(
Conv2d(15, 32, kernel_size=(7, 7), stride=1, padding=3),
Conv2d(32, 64, kernel_size=5, stride=(1, 2), padding=1),
Conv2d(64, 64, kernel_size=3, stride=1, padding=1, residual=True),
Conv2d(64, 64, kernel_size=3, stride=1, padding=1, residual=True),
Conv2d(64, 128, kernel_size=3, stride=2, padding=1),
Conv2d(128, 128, kernel_size=3, stride=1, padding=1, residual=True),
Conv2d(128, 128, kernel_size=3, stride=1, padding=1, residual=True),
Conv2d(128, 128, kernel_size=3, stride=1, padding=1, residual=True),
Conv2d(128, 256, kernel_size=3, stride=2, padding=1),
Conv2d(256, 256, kernel_size=3, stride=1, padding=1, residual=True),
Conv2d(256, 256, kernel_size=3, stride=1, padding=1, residual=True),
Conv2d(256, 512, kernel_size=3, stride=2, padding=1),
Conv2d(512, 512, kernel_size=3, stride=1, padding=1, residual=True),
Conv2d(512, 512, kernel_size=3, stride=1, padding=1, residual=True),
Conv2d(512, 512, kernel_size=3, stride=2, padding=1),
Conv2d(512, 512, kernel_size=3, stride=1, padding=0),
Conv2d(512, 512, kernel_size=1, stride=1, padding=0),)
def forward(self, face_sequences): # audio_sequences := (B, dim, T)
face_embedding = self.face_encoder(face_sequences)
face_embedding = face_embedding.view(face_embedding.size(0), -1)
face_embedding = F.normalize(face_embedding, p=2, dim=1)
return face_embedding
输入shape为(15, 222, 444)， 我希望输出(512,1, ), 这里改变AdaptiveAvgPool2d比较好还是改变kernel_size比较好
|
b061004475019dbb474a8473f486a4d6
|
{
"intermediate": 0.2114877700805664,
"beginner": 0.5189659595489502,
"expert": 0.2695463299751282
}
|
8,908
|
flutter slivergrid with dynamic aspect ratio is possible? how?
|
041c7aeef20fbaa964fe30defdd7f3ec
|
{
"intermediate": 0.3924938142299652,
"beginner": 0.15721042454242706,
"expert": 0.45029571652412415
}
|
8,909
|
мне нужно изменить light: {type:‘v3’, value: new THREE.Vector3()} вне цикла
for(let i = 0; i < positions.length; i+=3){
const max = 0.03;
const min = 0.055;
pointSize[i] = Math.random() * (max - min) + min;
pointSize[i+1] = Math.random() * (max - min) + min;
pointSize[i+2] = Math.random() * (max - min) + min;
const pointGeometry = new THREE.CircleGeometry(pointSize[i], 50);
const pointMaterial = new THREE.ShaderMaterial({
uniforms:{
mouseCoord: {type:‘v3’, value: new THREE.Vector3()},
light: {type:‘v3’, value: new THREE.Vector3()},
tex: { type:‘t’, value:texture2 },
opacity: { type:‘f’, value: Math.random() }, // генерируем уникальную прозрачность для каждой точки
res: { type:‘v2’, value:new THREE.Vector2(window.innerWidth,window.innerHeight)}
},
fragmentShader:shaderCode,
side: THREE.DoubleSide,
transparent: true
});
// uniforms.light.value.z = 500;
const point = new THREE.Mesh(pointGeometry, pointMaterial);
const posX = randomPosition[i];
const posY = randomPosition[i+1];
const posZ = randomPosition[i+2];
point.position.set(posX, posY, posZ);
pointsArr.push(point);
pointSize.push(pointSize[i]);
}
|
6c872150a11f483f77a0c09505e30e05
|
{
"intermediate": 0.32949456572532654,
"beginner": 0.3457566797733307,
"expert": 0.32474878430366516
}
|
8,910
|
How can I independently (without modules) determine the format of a log file in filebeat?
|
ac332c3d40c9d51814c1a466e1c14ac2
|
{
"intermediate": 0.4505106806755066,
"beginner": 0.1584819108247757,
"expert": 0.39100733399391174
}
|
8,911
|
I’m building a video game engine using C++ as the coding language and Vulkan for graphics. I am trying to set up a generic renderer using Vulkan that is flexible and will render objects based on a vector that is supplied to it. The renderer will also handle the creation of the window using GLFW and use GLM for all relevant math calls. I am using the ASSIMP library to load 3d models and animations.
Here is a portion of the code:
Renderer.h:
#pragma once
#include <vulkan/vulkan.h>
#include "Window.h"
#include <vector>
#include <stdexcept>
#include <set>
#include <optional>
#include <iostream>
#include "Pipeline.h"
#include "Material.h"
#include "Mesh.h"
struct QueueFamilyIndices
{
std::optional<uint32_t> graphicsFamily;
std::optional<uint32_t> presentFamily;
bool IsComplete()
{
return graphicsFamily.has_value() && presentFamily.has_value();
}
};
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities;
std::vector<VkSurfaceFormatKHR> formats;
std::vector<VkPresentModeKHR> presentModes;
};
class Renderer
{
public:
Renderer();
~Renderer();
void Initialize(GLFWwindow* window);
void Shutdown();
void BeginFrame();
void EndFrame();
VkDescriptorSetLayout CreateDescriptorSetLayout();
VkDescriptorPool CreateDescriptorPool(uint32_t maxSets);
VkDevice* GetDevice();
VkPhysicalDevice* GetPhysicalDevice();
VkCommandPool* GetCommandPool();
VkQueue* GetGraphicsQueue();
VkCommandBuffer* GetCurrentCommandBuffer();
std::shared_ptr<Pipeline> GetPipeline();
void CreateGraphicsPipeline(Mesh* mesh, Material* material);
private:
bool shutdownInProgress;
uint32_t currentCmdBufferIndex = 0;
std::vector<size_t> currentFramePerImage;
std::vector<VkImage> swapChainImages;
std::vector<VkImageView> swapChainImageViews;
VkExtent2D swapChainExtent;
VkRenderPass renderPass;
uint32_t imageIndex;
std::shared_ptr<Pipeline> pipeline;
VkFormat swapChainImageFormat;
std::vector<VkCommandBuffer> commandBuffers;
void CreateImageViews();
void CleanupImageViews();
void CreateRenderPass();
void CleanupRenderPass();
void CreateSurface();
void DestroySurface();
void CreateInstance();
void CleanupInstance();
void ChoosePhysicalDevice();
void CreateDevice();
void CleanupDevice();
void CreateSwapchain();
void CleanupSwapchain();
void CreateCommandPool();
void CleanupCommandPool();
void CreateFramebuffers();
void CleanupFramebuffers();
void CreateCommandBuffers();
void CleanupCommandBuffers();
void Present();
GLFWwindow* window;
VkInstance instance = VK_NULL_HANDLE;
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
VkDevice device = VK_NULL_HANDLE;
VkSurfaceKHR surface;
VkSwapchainKHR swapchain;
VkCommandPool commandPool;
VkCommandBuffer currentCommandBuffer;
std::vector<VkFramebuffer> framebuffers;
// Additional Vulkan objects needed for rendering…
const uint32_t kMaxFramesInFlight = 2;
std::vector<VkSemaphore> imageAvailableSemaphores;
std::vector<VkSemaphore> renderFinishedSemaphores;
std::vector<VkFence> inFlightFences;
size_t currentFrame;
VkQueue graphicsQueue;
VkQueue presentQueue;
void CreateSyncObjects();
void CleanupSyncObjects();
SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface);
VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats);
VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes);
VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window);
std::vector<const char*> deviceExtensions = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME
};
std::vector<const char*> CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice);
QueueFamilyIndices GetQueueFamilyIndices(VkPhysicalDevice physicalDevice);
};
Renderer.cpp:
#include "Renderer.h"
Renderer::Renderer() : currentFrame(0), shutdownInProgress(false)
{
}
Renderer::~Renderer()
{
Shutdown();
}
void Renderer::Initialize(GLFWwindow* window)
{
this->window = window;
CreateInstance();
CreateSurface();
ChoosePhysicalDevice();
CreateDevice();
CreateSwapchain();
CreateRenderPass();
CreateCommandPool();
CreateFramebuffers();
CreateSyncObjects();
}
void Renderer::Shutdown()
{
if (shutdownInProgress) {
return;
}
shutdownInProgress = true;
if (device != VK_NULL_HANDLE) {
vkDeviceWaitIdle(device);
}
CleanupFramebuffers();
CleanupRenderPass();
CleanupSyncObjects();
CleanupCommandBuffers();
CleanupCommandPool();
CleanupImageViews();
CleanupSwapchain();
if (device != VK_NULL_HANDLE) {
CleanupDevice();
}
DestroySurface();
CleanupInstance();
shutdownInProgress = false;
}
void Renderer::BeginFrame()
{
// Wait for any previous work on this swapchain image to complete
vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
vkResetFences(device, 1, &inFlightFences[currentFrame]);
// Acquire an image from the swapchain, then begin recording commands for the current frame.
VkResult acquireResult = vkAcquireNextImageKHR(device, swapchain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
if (acquireResult != VK_SUCCESS && acquireResult != VK_SUBOPTIMAL_KHR) {
throw std::runtime_error("Failed to acquire next swapchain image.");
}
VkCommandBufferBeginInfo beginInfo{};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
currentCmdBufferIndex = (currentCmdBufferIndex + 1) % 2;
currentCommandBuffer = commandBuffers[imageIndex];
// Add debug message before vkBeginCommandBuffer
std::cout << "Current Frame: " << currentFrame << " | Cmd Buffer Index: " << currentCmdBufferIndex << " | Image Index: " << imageIndex << "\n";
std::cout << "Calling vkBeginCommandBuffer…\n";
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
std::cout << "vkBeginCommandBuffer called…\n";
VkRenderPassBeginInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
renderPassInfo.renderPass = renderPass;
renderPassInfo.framebuffer = framebuffers[imageIndex];
renderPassInfo.renderArea.offset = { 0, 0 };
renderPassInfo.renderArea.extent = swapChainExtent;
// Set the clear color to black
VkClearValue clearColor = { 0.0f, 0.0f, 0.0f, 1.0f };
renderPassInfo.clearValueCount = 1;
renderPassInfo.pClearValues = &clearColor;
vkCmdBeginRenderPass(currentCommandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
}
void Renderer::EndFrame()
{
vkCmdEndRenderPass(currentCommandBuffer);
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &imageAvailableSemaphores[currentFrame];
submitInfo.pWaitDstStageMask = waitStages;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = ¤tCommandBuffer;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &renderFinishedSemaphores[currentFrame];
vkEndCommandBuffer(currentCommandBuffer);
vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]);
VkPresentInfoKHR presentInfo{};
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.waitSemaphoreCount = 1;
presentInfo.pWaitSemaphores = &renderFinishedSemaphores[currentFrame];
VkSwapchainKHR swapChains[] = { swapchain };
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = swapChains;
presentInfo.pImageIndices = &imageIndex;
VkResult queuePresentResult = vkQueuePresentKHR(presentQueue, &presentInfo);
std::cout << "Frame rendered: " << currentFrame << "\n";
if (queuePresentResult == VK_ERROR_OUT_OF_DATE_KHR || queuePresentResult == VK_SUBOPTIMAL_KHR) {
// Handle swapchain recreation if needed, e.g., due to resizing the window or other swapchain properties changes
}
else if (queuePresentResult != VK_SUCCESS) {
throw std::runtime_error("Failed to present the swapchain image.");
}
currentFrame = (currentFrame + 1) % kMaxFramesInFlight;
}
void Renderer::CreateSurface()
{
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a window surface.");
}
}
void Renderer::DestroySurface()
{
vkDestroySurfaceKHR(instance, surface, nullptr);
}
void Renderer::CreateInstance()
{
// Set up the application info
VkApplicationInfo appInfo{};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = "Game Engine";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "Game Engine";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_2;
// Set up the instance create info
VkInstanceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;
// Set up the required extensions
uint32_t glfwExtensionCount = 0;
const char** glfwExtensions;
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
createInfo.enabledExtensionCount = glfwExtensionCount;
createInfo.ppEnabledExtensionNames = glfwExtensions;
createInfo.enabledLayerCount = 0;
// Create the Vulkan instance
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create the Vulkan instance.");
}
std::vector<const char*> validationLayers;
#ifdef NDEBUG
const bool enableValidationLayers = false;
#else
const bool enableValidationLayers = true;
validationLayers.push_back("VK_LAYER_KHRONOS_validation");
#endif
if (enableValidationLayers) {
// Check if validation layers are supported
uint32_t layerCount;
vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
std::vector<VkLayerProperties> availableLayers(layerCount);
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
for (const char* layerName : validationLayers) {
bool layerFound = false;
for (const auto& layerProperties : availableLayers) {
if (strcmp(layerName, layerProperties.layerName) == 0) {
layerFound = true;
break;
}
}
if (!layerFound) {
throw std::runtime_error("Validation layer requested, but it’s not available.");
}
}
// Enable the validation layers
createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
createInfo.ppEnabledLayerNames = validationLayers.data();
}
else {
createInfo.enabledLayerCount = 0;
}
}
void Renderer::CleanupInstance()
{
// Destroy the Vulkan instance
vkDestroyInstance(instance, nullptr);
}
void Renderer::ChoosePhysicalDevice()
{
// Enumerate the available physical devices and choose one that supports required features
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
if (deviceCount == 0)
{
throw std::runtime_error("Failed to find a GPU with Vulkan support.");
}
std::vector<VkPhysicalDevice> allDevices(deviceCount);
vkEnumeratePhysicalDevices(instance, &deviceCount, allDevices.data());
for (const auto& testDevice : allDevices)
{
if (glfwGetPhysicalDevicePresentationSupport(instance, testDevice, 0) &&
CheckPhysicalDeviceExtensionSupport(testDevice).empty() &&
GetQueueFamilyIndices(testDevice).IsComplete())
{
physicalDevice = testDevice;
break;
}
}
if (physicalDevice == VK_NULL_HANDLE)
{
throw std::runtime_error("Failed to find a suitable GPU.");
}
}
void Renderer::CreateDevice()
{
// Get the GPU’s queue family indices
const QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
// Set up the device queue create info
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
std::set<uint32_t> uniqueQueueFamilyIndices = { indices.graphicsFamily.value(),indices.presentFamily.value() };
float queuePriority = 1.0f;
for (uint32_t queueFamilyIndex : uniqueQueueFamilyIndices)
{
VkDeviceQueueCreateInfo queueCreateInfo{};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = queueFamilyIndex;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = &queuePriority;
queueCreateInfos.push_back(queueCreateInfo);
}
// Set up the physical device features
VkPhysicalDeviceFeatures deviceFeatures{};
// Set up the device create info
VkDeviceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
createInfo.pQueueCreateInfos = queueCreateInfos.data();
createInfo.pEnabledFeatures = &deviceFeatures;
createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
createInfo.ppEnabledExtensionNames = deviceExtensions.data();
// Create the logical device
if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a logical device.");
}
// Retrieve the graphics queue and the present queue
vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
}
void Renderer::CleanupDevice()
{
// Destroy the logical device
vkDestroyDevice(device, nullptr);
}
void Renderer::CreateSwapchain()
{
// Get swapchain support details
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice,surface);
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
swapChainImageFormat = surfaceFormat.format; // Initialize the swapChainImageFormat
VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities,window);
uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount)
{
imageCount = swapChainSupport.capabilities.maxImageCount;
}
// Create the swapchain
// …
VkSwapchainCreateInfoKHR createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = surface;
createInfo.minImageCount = imageCount;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() };
if (indices.graphicsFamily != indices.presentFamily) {
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
}
else {
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
}
createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapchain) != VK_SUCCESS) {
throw std::runtime_error("failed to create swap chain!");
}
// Retrieve swapchain images (color buffers)
// …
// Retrieve swapchain images
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, nullptr);
swapChainImages.resize(imageCount);
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, swapChainImages.data());
// Create image views for swapchain images
CreateImageViews();
}
void Renderer::CleanupSwapchain()
{
// Clean up Vulkan swapchain
if (swapchain != VK_NULL_HANDLE)
{
vkDestroySwapchainKHR(device, swapchain, nullptr);
swapchain = VK_NULL_HANDLE;
}
}
void Renderer::CreateImageViews()
{
swapChainImageViews.resize(swapChainImages.size());
for (size_t i = 0; i < swapChainImages.size(); ++i)
{
VkImageViewCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
createInfo.image = swapChainImages[i];
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
createInfo.format = swapChainImageFormat;
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
createInfo.subresourceRange.baseMipLevel = 0;
createInfo.subresourceRange.levelCount = 1;
createInfo.subresourceRange.baseArrayLayer = 0;
createInfo.subresourceRange.layerCount = 1;
createInfo.flags = 0;
if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create an image view.");
}
}
}
void Renderer::CleanupImageViews()
{
for (auto imageView : swapChainImageViews)
{
vkDestroyImageView(device, imageView, nullptr);
}
swapChainImageViews.clear();
}
void Renderer::CreateRenderPass()
{
VkAttachmentDescription colorAttachment{};
colorAttachment.format = swapChainImageFormat;
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
VkAttachmentReference colorAttachmentRef{};
colorAttachmentRef.attachment = 0;
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass{};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &colorAttachmentRef;
VkRenderPassCreateInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassInfo.attachmentCount = 1;
renderPassInfo.pAttachments = &colorAttachment;
renderPassInfo.subpassCount = 1;
renderPassInfo.pSubpasses = &subpass;
VkSubpassDependency dependency{};
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
dependency.dstSubpass = 0;
dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.srcAccessMask = 0;
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
renderPassInfo.dependencyCount = 1;
renderPassInfo.pDependencies = &dependency;
if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create render pass.");
}
}
void Renderer::CleanupRenderPass()
{
vkDestroyRenderPass(device, renderPass, nullptr);
}
void Renderer::CreateCommandPool()
{
// Find a queue family index that supports graphics operations
QueueFamilyIndices queueFamilyIndices = GetQueueFamilyIndices(physicalDevice);
// Create a command pool for the queue family
VkCommandPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
poolInfo.flags = 0;
if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create command pool.");
}
CreateCommandBuffers(); // Create command buffers after creating the command pool
}
void Renderer::CleanupCommandPool()
{
// Clean up Vulkan command pool
CleanupCommandBuffers(); // Add this line to clean up command buffers before destroying the command pool
vkDestroyCommandPool(device, commandPool, nullptr);
}
void Renderer::CreateCommandBuffers()
{
commandBuffers.resize(swapChainImages.size());
VkCommandBufferAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.commandPool = commandPool;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandBufferCount = static_cast<uint32_t>(commandBuffers.size());
if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS)
{
throw std::runtime_error("Failed to allocate command buffers.");
}
// Set the initial value of the currentCommandBuffer
currentCommandBuffer = commandBuffers[currentFrame];
}
void Renderer::CleanupCommandBuffers()
{
vkFreeCommandBuffers(device, commandPool, static_cast<uint32_t>(commandBuffers.size()), commandBuffers.data());
}
void Renderer::CreateFramebuffers()
{
// Check if the framebuffers vector is not empty, and call CleanupFramebuffers()
if (!framebuffers.empty()) {
CleanupFramebuffers();
}
// Create Vulkan framebuffers for swapchain images
framebuffers.resize(swapChainImageViews.size());
for (size_t i = 0; i < swapChainImageViews.size(); ++i)
{
VkImageView attachments[] = { swapChainImageViews[i] };
VkFramebufferCreateInfo framebufferInfo{};
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebufferInfo.renderPass = renderPass;
framebufferInfo.attachmentCount = 1;
framebufferInfo.pAttachments = attachments;
framebufferInfo.width = swapChainExtent.width;
framebufferInfo.height = swapChainExtent.height;
framebufferInfo.layers = 1;
if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &framebuffers[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create framebuffer.");
}
}
}
void Renderer::CleanupFramebuffers()
{
for (auto framebuffer : framebuffers)
{
if (framebuffer != VK_NULL_HANDLE)
{
vkDestroyFramebuffer(device, framebuffer, nullptr);
framebuffer = VK_NULL_HANDLE;
}
}
framebuffers.clear(); // Make sure to clear the framebuffers vector after destroying each framebuffer
}
void Renderer::CreateSyncObjects()
{
imageAvailableSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
renderFinishedSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
inFlightFences.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
VkSemaphoreCreateInfo semaphoreInfo{};
semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
VkFenceCreateInfo fenceInfo{};
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS ||
vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS ||
vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create synchronization objects for a frame.");
}
}
}
void Renderer::CleanupSyncObjects()
{
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (renderFinishedSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);
if (imageAvailableSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);
if (inFlightFences[i] != VK_NULL_HANDLE)
vkDestroyFence(device, inFlightFences[i], nullptr);
}
}
SwapChainSupportDetails Renderer::querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface)
{
SwapChainSupportDetails details;
// Query the capabilities
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
// Query the supported formats
uint32_t formatCount;
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
if (formatCount != 0)
{
details.formats.resize(formatCount);
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
}
// Query the supported present modes
uint32_t presentModeCount;
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
if (presentModeCount != 0)
{
details.presentModes.resize(presentModeCount);
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
}
return details;
}
VkSurfaceFormatKHR Renderer::chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats)
{
for (const auto& availableFormat : availableFormats)
{
if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
{
return availableFormat;
}
}
return availableFormats[0];
}
VkPresentModeKHR Renderer::chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes)
{
for (const auto& availablePresentMode : availablePresentModes)
{
if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR)
{
return availablePresentMode;
}
}
return VK_PRESENT_MODE_FIFO_KHR;
}
VkExtent2D Renderer::chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window)
{
if (capabilities.currentExtent.width != UINT32_MAX)
{
return capabilities.currentExtent;
}
else
{
int width, height;
glfwGetFramebufferSize(window, &width, &height);
VkExtent2D actualExtent = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
actualExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, actualExtent.width));
actualExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, actualExtent.height));
return actualExtent;
}
}
std::vector<const char*> Renderer::CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice)
{
uint32_t extensionCount;
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, nullptr);
std::vector<VkExtensionProperties> availableExtensions(extensionCount);
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, availableExtensions.data());
std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
for (const auto& extension : availableExtensions)
{
requiredExtensions.erase(extension.extensionName);
}
std::vector<const char*> remainingExtensions;
for (const auto& extension : requiredExtensions)
{
remainingExtensions.push_back(extension.c_str());
}
return remainingExtensions;
}
QueueFamilyIndices Renderer::GetQueueFamilyIndices(VkPhysicalDevice physicalDevice)
{
QueueFamilyIndices indices;
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr);
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilies.data());
int i = 0;
for (const auto& queueFamily : queueFamilies)
{
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
indices.graphicsFamily = i;
}
VkBool32 presentSupport = false;
vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, surface, &presentSupport);
if (presentSupport)
{
indices.presentFamily = i;
}
if (indices.IsComplete())
{
break;
}
i++;
}
return indices;
}
VkDevice* Renderer::GetDevice() {
return &device;
};
VkPhysicalDevice* Renderer::GetPhysicalDevice() {
return &physicalDevice;
};
VkCommandPool* Renderer::GetCommandPool() {
return &commandPool;
};
VkQueue* Renderer::GetGraphicsQueue() {
return &graphicsQueue;
};
VkCommandBuffer* Renderer::GetCurrentCommandBuffer() {
return ¤tCommandBuffer;
}
VkDescriptorSetLayout Renderer::CreateDescriptorSetLayout() {
VkDescriptorSetLayoutBinding uboLayoutBinding{};
uboLayoutBinding.binding = 0;
uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
uboLayoutBinding.descriptorCount = 1;
uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
uboLayoutBinding.pImmutableSamplers = nullptr;
VkDescriptorSetLayoutCreateInfo layoutInfo{};
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layoutInfo.bindingCount = 1;
layoutInfo.pBindings = &uboLayoutBinding;
VkDescriptorSetLayout descriptorSetLayout;
if (vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &descriptorSetLayout) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor set layout!");
}
return descriptorSetLayout;
}
VkDescriptorPool Renderer::CreateDescriptorPool(uint32_t maxSets) {
VkDescriptorPoolSize poolSize{};
poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
poolSize.descriptorCount = maxSets;
VkDescriptorPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
poolInfo.poolSizeCount = 1;
poolInfo.pPoolSizes = &poolSize;
poolInfo.maxSets = maxSets;
VkDescriptorPool descriptorPool;
if (vkCreateDescriptorPool(device, &poolInfo, nullptr, &descriptorPool) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor pool!");
}
return descriptorPool;
}
void Renderer::CreateGraphicsPipeline(Mesh* mesh, Material* material) {
if (pipeline)
{
pipeline->Cleanup();
}
// Create pipeline object and configure its properties
pipeline = std::make_shared<Pipeline>();
pipeline->CreateGraphicsPipeline(mesh->GetVertexInputBindingDescriptions(),
mesh->GetVertexInputAttributeDescriptions(),
swapChainExtent,
{material->GetvertexShader().get(), material->GetfragmentShader().get()},
renderPass,
material->GetPipelineLayout(),
device);
}
std::shared_ptr<Pipeline> Renderer::GetPipeline() {
return pipeline;
}
The code seems to hang at this line of code in the Renderer::BeginFrame method:
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
It compeltes a full cycle of imageindices, but still hangs a bit later. Here is the last lines of console outputs:
Current Frame: 0 | Cmd Buffer Index: 1 | Image Index: 1
Calling vkBeginCommandBuffer
What changes to the code would fix this?
|
f38fabfa3b054a3cb33f9d4a3b57da68
|
{
"intermediate": 0.4038229286670685,
"beginner": 0.3279862403869629,
"expert": 0.268190860748291
}
|
8,912
|
python create a script that looks through weapons.meta files that are within folders in a base folder the open the weapons.meta and find the text WEAPON_ and append the WEAPON_name to a txt document
here is a an example of what the weapons.meta file looks like
<?xml version="1.0" encoding="UTF-8"?>
<CWeaponInfoBlob>
<SlotNavigateOrder>
<Item>
<WeaponSlots>
<Item>
<OrderNumber value="180" />
<Entry>SLOT_AK971</Entry>
</Item>
</WeaponSlots>
</Item>
<Item>
<WeaponSlots>
<Item>
<OrderNumber value="190" />
<Entry>SLOT_AK971</Entry>
</Item>
</WeaponSlots>
</Item>
</SlotNavigateOrder>
<SlotBestOrder>
<WeaponSlots>
<Item>
<OrderNumber value="60" />
<Entry>SLOT_AK971</Entry>
</Item>
</WeaponSlots>
</SlotBestOrder>
<TintSpecValues />
<FiringPatternAliases />
<UpperBodyFixupExpressionData />
<AimingInfos />
<Infos>
<Item>
<Infos>
<Item type="CWeaponInfo">
<Name>WEAPON_AK971</Name>
<Model>W_AR_AK971</Model>
<Audio>AUDIO_ITEM_ASSAULTRIFLE</Audio>
<Slot>SLOT_AK971</Slot>
<DamageType>BULLET</DamageType>
<Explosion>
<Default>DONTCARE</Default>
<HitCar>DONTCARE</HitCar>
<HitTruck>DONTCARE</HitTruck>
<HitBike>DONTCARE</HitBike>
<HitBoat>DONTCARE</HitBoat>
<HitPlane>DONTCARE</HitPlane>
</Explosion>
<FireType>INSTANT_HIT</FireType>
<WheelSlot>WHEEL_RIFLE</WheelSlot>
<Group>GROUP_RIFLE</Group>
<AmmoInfo ref="AMMO_RIFLE" />
<AimingInfo ref="RIFLE_LO_BASE_STRAFE" />
<ClipSize value="30" />
<AccuracySpread value="3.000000" />
<AccurateModeAccuracyModifier value="0.500000" />
<RunAndGunAccuracyModifier value="2.000000" />
<RunAndGunAccuracyMaxModifier value="1.000000" />
<RecoilAccuracyMax value="0.500000" />
<RecoilErrorTime value="3.000000" />
<RecoilRecoveryRate value="1.000000" />
<RecoilAccuracyToAllowHeadShotAI value="1000.000000" />
<MinHeadShotDistanceAI value="1000.000000" />
<MaxHeadShotDistanceAI value="1000.000000" />
<HeadShotDamageModifierAI value="1000.000000" />
<RecoilAccuracyToAllowHeadShotPlayer value="0.175000" />
<MinHeadShotDistancePlayer value="5.000000" />
<MaxHeadShotDistancePlayer value="40.000000" />
<HeadShotDamageModifierPlayer value="1.500000" />
<Damage value="32.000000" />
<DamageTime value="0.000000" />
<DamageTimeInVehicle value="0.000000" />
<DamageTimeInVehicleHeadShot value="0.000000" />
<HitLimbsDamageModifier value="0.500000" />
<NetworkHitLimbsDamageModifier value="0.800000" />
<LightlyArmouredDamageModifier value="0.750000" />
<Force value="75.000000" />
<ForceHitPed value="140.000000" />
<ForceHitVehicle value="1200.000000" />
<ForceHitFlyingHeli value="1250.000000" />
<OverrideForces>
<Item>
<BoneTag>BONETAG_HEAD</BoneTag>
<ForceFront value="80.000000" />
<ForceBack value="50.000000" />
</Item>
<Item>
<BoneTag>BONETAG_NECK</BoneTag>
<ForceFront value="60.000000" />
<ForceBack value="90.000000" />
</Item>
<Item>
<BoneTag>BONETAG_L_THIGH</BoneTag>
<ForceFront value="40.000000" />
<ForceBack value="1.000000" />
</Item>
<Item>
<BoneTag>BONETAG_R_THIGH</BoneTag>
<ForceFront value="40.000000" />
<ForceBack value="1.000000" />
</Item>
<Item>
<BoneTag>BONETAG_L_CALF</BoneTag>
<ForceFront value="70.000000" />
<ForceBack value="80.000000" />
</Item>
<Item>
<BoneTag>BONETAG_R_CALF</BoneTag>
<ForceFront value="60.000000" />
<ForceBack value="100.000000" />
</Item>
</OverrideForces>
<ForceMaxStrengthMult value="1.000000" />
<ForceFalloffRangeStart value="0.000000" />
<ForceFalloffRangeEnd value="50.000000" />
<ForceFalloffMin value="1.000000" />
<ProjectileForce value="0.000000" />
<FragImpulse value="600.000000" />
<Penetration value="0.100000" />
<VerticalLaunchAdjustment value="0.000000" />
<DropForwardVelocity value="0.000000" />
<Speed value="2000.000000" />
<BulletsInBatch value="1" />
<BatchSpread value="0.000000" />
<ReloadTimeMP value="-1.000000" />
<ReloadTimeSP value="-1.000000" />
<VehicleReloadTime value="1.000000" />
<AnimReloadRate value="0.900000" />
<BulletsPerAnimLoop value="1" />
<TimeBetweenShots value="0.139000" />
<TimeLeftBetweenShotsWhereShouldFireIsCached value="-1.000000" />
<SpinUpTime value="0.000000" />
<SpinTime value="0.000000" />
<SpinDownTime value="0.000000" />
<AlternateWaitTime value="-1.000000" />
<BulletBendingNearRadius value="0.000000" />
<BulletBendingFarRadius value="0.750000" />
<BulletBendingZoomedRadius value="0.375000" />
<FirstPersonBulletBendingNearRadius value="0.000000" />
<FirstPersonBulletBendingFarRadius value="0.750000" />
<FirstPersonBulletBendingZoomedRadius value="0.375000" />
<Fx>
<EffectGroup>WEAPON_EFFECT_GROUP_RIFLE_ASSAULT</EffectGroup>
<FlashFx>muz_assault_rifle</FlashFx>
<FlashFxAlt>muz_alternate_star</FlashFxAlt>
<FlashFxFP>muz_assault_rifle_fp</FlashFxFP>
<FlashFxAltFP />
<MuzzleSmokeFx>muz_smoking_barrel</MuzzleSmokeFx>
<MuzzleSmokeFxFP>muz_smoking_barrel_fp</MuzzleSmokeFxFP>
<MuzzleSmokeFxMinLevel value="0.300000" />
<MuzzleSmokeFxIncPerShot value="0.100000" />
<MuzzleSmokeFxDecPerSec value="0.250000" />
<ShellFx>eject_auto</ShellFx>
<ShellFxFP>eject_auto_fp</ShellFxFP>
<TracerFx>bullet_tracer</TracerFx>
<PedDamageHash>BulletLarge</PedDamageHash>
<TracerFxChanceSP value="0.150000" />
<TracerFxChanceMP value="0.750000" />
<FlashFxChanceSP value="1.000000" />
<FlashFxChanceMP value="1.000000" />
<FlashFxAltChance value="0.200000" />
<FlashFxScale value="1.000000" />
<FlashFxLightEnabled value="true" />
<FlashFxLightCastsShadows value="false" />
<FlashFxLightOffsetDist value="0.000000" />
<FlashFxLightRGBAMin x="255.000000" y="93.000000" z="25.000000" />
<FlashFxLightRGBAMax x="255.000000" y="100.000000" z="50.000000" />
<FlashFxLightIntensityMinMax x="1.000000" y="2.000000" />
<FlashFxLightRangeMinMax x="2.500000" y="3.500000" />
<FlashFxLightFalloffMinMax x="1024.000000" y="1536.000000" />
<GroundDisturbFxEnabled value="false" />
<GroundDisturbFxDist value="5.000000" />
<GroundDisturbFxNameDefault />
<GroundDisturbFxNameSand />
<GroundDisturbFxNameDirt />
<GroundDisturbFxNameWater />
<GroundDisturbFxNameFoliage />
</Fx>
<InitialRumbleDuration value="90" />
<InitialRumbleIntensity value="0.700000" />
<InitialRumbleIntensityTrigger value="0.950000" />
<RumbleDuration value="90" />
<RumbleIntensity value="0.100000" />
<RumbleIntensityTrigger value="0.800000" />
<RumbleDamageIntensity value="1.000000" />
<InitialRumbleDurationFps value="150" />
<InitialRumbleIntensityFps value="1.000000" />
<RumbleDurationFps value="95" />
<RumbleIntensityFps value="1.000000" />
<NetworkPlayerDamageModifier value="1.000000" />
<NetworkPedDamageModifier value="1.000000" />
<NetworkHeadShotPlayerDamageModifier value="1.700000" />
<LockOnRange value="65.000000" />
<WeaponRange value="200.000000" />
<BulletDirectionOffsetInDegrees value="0.000000" />
<AiSoundRange value="-1.000000" />
<AiPotentialBlastEventRange value="-1.000000" />
<DamageFallOffRangeMin value="49.500000" />
<DamageFallOffRangeMax value="200.000000" />
<DamageFallOffModifier value="0.300000" />
<VehicleWeaponHash />
<DefaultCameraHash>DEFAULT_THIRD_PERSON_PED_AIM_CAMERA</DefaultCameraHash>
<CoverCameraHash>DEFAULT_THIRD_PERSON_PED_AIM_IN_COVER_CAMERA</CoverCameraHash>
<CoverReadyToFireCameraHash />
<RunAndGunCameraHash>DEFAULT_THIRD_PERSON_PED_RUN_AND_GUN_CAMERA</RunAndGunCameraHash>
<CinematicShootingCameraHash>DEFAULT_THIRD_PERSON_PED_CINEMATIC_SHOOTING_CAMERA</CinematicShootingCameraHash>
<AlternativeOrScopedCameraHash />
<RunAndGunAlternativeOrScopedCameraHash />
<CinematicShootingAlternativeOrScopedCameraHash />
<CameraFov value="35.000000" />
<FirstPersonScopeFov value="20.00000"/>
<FirstPersonScopeAttachmentFov value="20.00000"/>
<FirstPersonRNGOffset x="0.000000" y="0.000000" z="0.000000" />
<FirstPersonRNGRotationOffset x="0.000000" y="0.000000" z="0.000000" />
<FirstPersonLTOffset x="0.000000" y="0.000000" z="0.000000" />
<FirstPersonLTRotationOffset x="0.000000" y="0.000000" z="0.000000" />
<FirstPersonScopeOffset x="0.00000" y="-0.0200" z="-0.0230" />
<FirstPersonScopeAttachmentOffset x="0.00000" y="0.0000" z="-0.0280" />
<FirstPersonScopeRotationOffset x="-0.70000" y="0.0000" z="0.0000" />
<FirstPersonScopeAttachmentRotationOffset x="0.00000" y="0.0000" z="0.0000" />
<FirstPersonAsThirdPersonIdleOffset x="-0.07500000" y="0.000000" z="-0.05" />
<FirstPersonAsThirdPersonRNGOffset x="-0.025000" y="0.000000" z="-0.075000" />
<FirstPersonAsThirdPersonLTOffset x="0.025000" y="0.000000" z="-0.0750000" />
<FirstPersonAsThirdPersonScopeOffset x="0.075000" y="-0.050000" z="-0.060000" />
<FirstPersonAsThirdPersonWeaponBlockedOffset x="-0.1000000" y="0.000000" z="-0.100000" />
<FirstPersonDofSubjectMagnificationPowerFactorNear value="1.025000" />
<FirstPersonDofMaxNearInFocusDistance value="0.000000" />
<FirstPersonDofMaxNearInFocusDistanceBlendLevel value="0.300000" />
<ZoomFactorForAccurateMode value="1.300000" />
<RecoilShakeHash>ASSAULT_RIFLE_RECOIL_SHAKE</RecoilShakeHash>
<RecoilShakeHashFirstPerson>FPS_ASSAULT_RIFLE_RECOIL_SHAKE</RecoilShakeHashFirstPerson>
<AccuracyOffsetShakeHash>DEFAULT_THIRD_PERSON_ACCURACY_OFFSET_SHAKE</AccuracyOffsetShakeHash>
<MinTimeBetweenRecoilShakes value="100" />
<RecoilShakeAmplitude value="0.333000" />
<ExplosionShakeAmplitude value="-1.000000" />
<ReticuleHudPosition x="0.000000" y="0.000000" />
<AimOffsetMin x="0.250000" y="0.200000" z="0.600000" />
<AimProbeLengthMin value="0.430000" />
<AimOffsetMax x="0.165000" y="-0.180000" z="0.470000" />
<AimProbeLengthMax value="0.340000" />
<AimOffsetMinFPSIdle x="0.162000" y="0.225000" z="0.052000" />
<AimOffsetMedFPSIdle x="0.187000" y="0.197000" z="0.321000" />
<AimOffsetMaxFPSIdle x="0.155000" y="0.038000" z="0.364000" />
<AimOffsetEndPosMinFPSIdle x="-0.284000" y="0.612000" z="-0.205000" />
<AimOffsetEndPosMedFPSIdle x="-0.178000" y="0.639000" z="0.616000" />
<AimOffsetEndPosMaxFPSIdle x="-0.21700" y="-0.096000" z="0.887000" />
<AimOffsetMinFPSLT x="0.180000" y="0.231000" z="0.669000" />
<AimOffsetMaxFPSLT x="0.048000" y="-0.225000" z="0.409000" />
<AimOffsetMinFPSRNG x="0.120000" y="0.275000" z="0.509000" />
<AimOffsetMaxFPSRNG x="0.138000" y="-0.212000" z="0.518000" />
<AimOffsetMinFPSScope x="0.090000" y="0.078000" z="0.531000" />
<AimOffsetMaxFPSScope x="0.006000" y="-0.059000" z="0.694000" />
<TorsoAimOffset x="-1.000000" y="0.550000" />
<TorsoCrouchedAimOffset x="0.100000" y="0.120000" />
<LeftHandIkOffset x="0.015000" y="0.095000" z="-0.008000" />
<ReticuleMinSizeStanding value="0.600000" />
<ReticuleMinSizeCrouched value="0.500000" />
<ReticuleScale value="0.300000" />
<ReticuleStyleHash>WEAPONTYPE_RIFLE</ReticuleStyleHash>
<FirstPersonReticuleStyleHash />
<PickupHash>PICKUP_WEAPON_AK971</PickupHash>
<MPPickupHash>PICKUP_AMMO_BULLET_MP</MPPickupHash>
<HumanNameHash>WT_AK971</HumanNameHash>
<MovementModeConditionalIdle>MMI_2Handed</MovementModeConditionalIdle>
<StatName>AK971</StatName>
<KnockdownCount value="-1" />
<KillshotImpulseScale value="1.000000" />
<NmShotTuningSet>Automatic</NmShotTuningSet>
<AttachPoints>
<Item>
<AttachBone>WAPClip</AttachBone>
<Components>
<Item>
<Name>COMPONENT_AK971_CLIP_01</Name>
<Default value="true" />
</Item>
</Components>
</Item>
</AttachPoints>
<GunFeedBone />
<TargetSequenceGroup />
<WeaponFlags>CarriedInHand Gun CanLockonOnFoot CanLockonInVehicle CanFreeAim TwoHanded AnimReload AnimCrouchFire UsableOnFoot UsableInCover AllowEarlyExitFromFireAnimAfterBulletFired NoLeftHandIKWhenBlocked HasLowCoverReloads HasLowCoverSwaps LongWeapon UseFPSAimIK UseFPSSecondaryMotion OnlyFireOneShotPerTriggerPress</WeaponFlags>
<TintSpecValues ref="TINT_DEFAULT" />
<FiringPatternAliases ref="FIRING_PATTERN_RIFLE" />
<ReloadUpperBodyFixupExpressionData ref="default" />
<AmmoDiminishingRate value="3" />
<AimingBreathingAdditiveWeight value="1.000000" />
<FiringBreathingAdditiveWeight value="1.000000" />
<StealthAimingBreathingAdditiveWeight value="1.000000" />
<StealthFiringBreathingAdditiveWeight value="1.000000" />
<AimingLeanAdditiveWeight value="1.000000" />
<FiringLeanAdditiveWeight value="1.000000" />
<StealthAimingLeanAdditiveWeight value="1.000000" />
<StealthFiringLeanAdditiveWeight value="1.000000" />
<ExpandPedCapsuleRadius value="0.000000" />
<AudioCollisionHash />
<HudDamage value="32" />
<HudSpeed value="65" />
<HudCapacity value="40" />
<HudAccuracy value="55" />
<HudRange value="45" />
</Item>
</Infos>
</Item>
<Item>
<Infos />
</Item>
<Item>
<Infos />
</Item>
</Infos>
<VehicleWeaponInfos />
<Name>AK971</Name>
</CWeaponInfoBlob>
In this example I was want it to return and add
WEAPON_AK971 to the txt document
|
74e31dbe8ea9aec3d4fecd5bf16997c5
|
{
"intermediate": 0.368640273809433,
"beginner": 0.44888418912887573,
"expert": 0.1824755221605301
}
|
8,913
|
I want the information in this site https://www.sec.gov/Archives/edgar/data/320193/000119312510238044/d10k.htm
|
f845f99957b3301758074397b4943f54
|
{
"intermediate": 0.29254522919654846,
"beginner": 0.2533576488494873,
"expert": 0.45409712195396423
}
|
8,914
|
python create a script that looks through weapons.meta files that are within folders in a base folder the open the weapons.meta and find the text WEAPON_ and append the WEAPON_name to a txt document
here is a an example of what the weapons.meta file looks like
<Infos>
<Item>
<Infos>
<Item type="CWeaponInfo">
<Name>WEAPON_AK971</Name>
In this example I was want it to return and add
WEAPON_AK971 to the txt document
don't use import xml.etree.ElementTree as ET
|
e52d3afc854cfce9a9349c40ccd71dfe
|
{
"intermediate": 0.43825456500053406,
"beginner": 0.2551840841770172,
"expert": 0.3065613806247711
}
|
8,915
|
is that correct from abc import ABC, abstractmethod
from typing import List, TypeVar, Generic
from uuid import UUID
INPUT_DTO = TypeVar('INPUT_DTO')
OUTPUT_DTO = TypeVar('OUTPUT_DTO')
ORM = TypeVar('ORM')
class BaseBusinessLogic(Generic[INPUT_DTO, OUTPUT_DTO, ORM], ABC):
@abstractmethod
async def create(self, obj: INPUT_DTO) -> OUTPUT_DTO:
pass
@abstractmethod
async def read_all(self) -> List[OUTPUT_DTO]:
pass
@abstractmethod
async def read(self, id: UUID) -> OUTPUT_DTO:
pass
@abstractmethod
async def update(self, id: UUID, obj: INPUT_DTO) -> OUTPUT_DTO:
pass
@abstractmethod
async def delete(self, id: UUID) -> OUTPUT_DTO:
pass
|
893794409052522ea3eaa90a5acaf057
|
{
"intermediate": 0.32202908396720886,
"beginner": 0.5742157697677612,
"expert": 0.10375513881444931
}
|
8,916
|
#include "mbed.h"
//#include "platform/mbed_thread.h"
#include <math.h>
#define SPI3_MOSI D11 //SDA
#define SPI3_MISO D12 //SDO
#define SPI3_SCLK D13 //SCL
#define SPI3_CS A3
#define I2CSDA PA_10
#define I2CSCL PA_9
DigitalOut LCD_RS(A0); // RS
DigitalOut LCD_EN(D9); // E
DigitalOut LCD_RW(D10); //RW
BusOut data1(D3, D4, D5, D6);
SPI ADXL345(SPI3_MOSI,SPI3_MISO,SPI3_SCLK);
I2C TMP102(I2CSDA,I2CSCL);
DigitalOut ADXL345_cs(SPI3_CS);
DigitalOut LXG1(A1);// the pin for green LED
DigitalOut LXR1(A2);// the pin for red LED
DigitalOut buzzer(D2);
Serial pc(USBTX, USBRX);
const int TMP102Address = 0x90; //TMP102 Address
char ConfigRegisterTMP102[3]; //Config Register
char TemperatureRegister[2]; //Temperature Register
float Temperature,lastT=0; //Final Temperature Value in Degree Celsius
char buffer[6];// read data
int16_t data[3];// compute x,y,z
float x,y,z,lastx=0,lasty=0,lastz=0;// x,y,z and their change value
float changesx,changesy,changesz,changesT;
float SumA;
DigitalIn button (A6,PullDown);
void lcdCommand(char value) {
LCD_RS = 0; // 设置为命令模式
//LCD_EN = 1; // 使能信号置高
LCD_RW = 0;
//LCD_EN = 0;
data1 = (value) >> 4;
LCD_EN = 1;
wait_ms(10);
LCD_EN = 0; // 使能信号置低，完成数据传输
data1 = (value);
LCD_EN = 1; // 使能信号置高，为下一次传输做准备
wait_ms(10);
LCD_EN = 0; // 使能信号置低，完成数据传输
}
void LCD_WriteData(char value) {
LCD_RS = 1; // 设置为数据模式
LCD_RW = 0; // 使能信号置高
//LCD_EN = 0;
data1 = (value) >> 4;
LCD_EN = 1;
wait_ms(10);
LCD_EN = 0; // 使能信号置低，完成数据传输
// 使能信号置高，为下一次传输做准备
data1 = (value);
LCD_EN = 1;
wait_ms(10);
LCD_EN = 0;
// 等待一段时间
}
void LCD_SetCursor(unsigned char Line,unsigned char Column)
{
if(Line==1)
{
lcdCommand(0x80|(Column-1));
}
else if(Line==2)
{
lcdCommand(0x80|(Column-1+0x40));
}
}
void ConfigureTMP102()
{
ConfigRegisterTMP102[0] = 0x01; //Point to config register
ConfigRegisterTMP102[1] = 0x60; //Upper byte with Shut Down disabled
ConfigRegisterTMP102[2] = 0xA0; //Lower byte
TMP102.write(TMP102Address, ConfigRegisterTMP102, 3); //Write 3 bytes
}
void ADXL345_SPI_Initialise()
{
ADXL345_cs=1;// strat wirte
ADXL345.format(8,3);
ADXL345.frequency(2000000);
ADXL345_cs=0;// end write
ADXL345.write(0x31);
ADXL345.write(0x0B);
ADXL345_cs=1;
ADXL345_cs=0;
ADXL345.write(0x2D);
ADXL345.write(0x08);
ADXL345_cs=1;
}
void LCD_Init()
{
// lcdCommand(0x38);
// lcdCommand(0x0c);
// lcdCommand(0x06);
// lcdCommand(0x01);
LCD_RS = 0;
LCD_EN = 0;
LCD_RW = 0;
lcdCommand(0x01); // 清屏
lcdCommand(0x02); // 显示模式，光标复位
lcdCommand(0x0);
lcdCommand(0x0c); // 显示开、光标关、闪烁关（一般做带键盘输入的才加入光标，常用的计量显示不显示光标）
lcdCommand(0x28); // 4位数据模式、两行显示、5*7点阵
lcdCommand(0x0);
lcdCommand(0x01); // 清屏
}
void LCD_ShowChar(unsigned char Line,unsigned char Column,char Char)
{
LCD_SetCursor(Line,Column);
LCD_WriteData(Char);
}
void LCD_ShowString(unsigned char Line,unsigned char Column,char *String)
{
unsigned char i;
LCD_SetCursor(Line,Column);
for(i=0;String[i]!='\0';i++)
{
LCD_WriteData(String[i]);
}
}
为这个代码加上英文注释请注意格式
|
ba3c1b6706a9a06e13b1892a538d2848
|
{
"intermediate": 0.4391365647315979,
"beginner": 0.4047122299671173,
"expert": 0.15615114569664001
}
|
8,917
|
python create a script that gets a base folder given
T:\Fivem Related\Alpha Dev\stream_weapons\metas\addon
and then copies all of the weapons.meta files into one folder and just call it weapons1.meta, weapons2.meta etc
|
a2c3a94327a908dbb2d41a9e6db6796e
|
{
"intermediate": 0.34578582644462585,
"beginner": 0.19213999807834625,
"expert": 0.4620742201805115
}
|
8,918
|
回答下述问题
1） 定义一个商品类CGoods，其中包含商品号(long no)、商品名(char *p_name)、商品价格(double price)三个数据成员，以及相应的构造函数、复制构造函数、析构函数、打印数据成员的成员函数。
#include <iostream>
#include <string.h>
using namespace std;
class CGoods
{
protected:
long no;
char *p_name;
double price;
public:
CGoods (long no_val, char * p_val, double price_val);
//提示：char数组长度可用strlen获得,注意strlen的结果是否包含\0了
CGoods (const CGoods & g ); //注意：不要创造浅拷贝
~CGoods (){delete [] p_name;}
void print() const;
};
2） 为CGoods类增加一个商品总数(int count)数据成员，并增加一个成员函数getCount()获取count的值，再编写一个友元函数getName()在类外获取输出商品名称p_name。
3） 为CGoods类定义小于运算符(‘<’)和不小于运算符(‘>=’)两个运算符重载函数。CGoods类对象大小的比较是根据其商品价格(price)的值的大小来实现的。
4） 以CGoods类为基类，派生出服装类CClothes和食品类CFood两个派生类，并在这两个类中分别增加一个表示品牌的指针数据成员(char *p_brand)和表示用途的成员函数(void usedFor()——函数体就是输出一条表示服装和食品用途的信息)。写出CClothes类和CFood类的完整定义(包括含参构造、复制构造、析构和usedFor()成员函数的实现)。
5）为了能够采用动态关联的方式调用派生类的usedFor()成员函数，实现多态性，应该在CGoods类及其派生类CClothes和CFood类中作何改动？ 主函数以何种方式调用？
|
dc6eb239ed19a809b819d4e625de4f13
|
{
"intermediate": 0.3367421627044678,
"beginner": 0.4537999629974365,
"expert": 0.2094579041004181
}
|
8,919
|
I’m building a video game engine using C++ as the coding language and Vulkan for graphics. I am trying to set up a generic renderer using Vulkan that is flexible and will render objects based on a vector that is supplied to it. The renderer will also handle the creation of the window using GLFW and use GLM for all relevant math calls. I am using the ASSIMP library to load 3d models and animations.
Here is a portion of the code:
Renderer.h:
#pragma once
#include <vulkan/vulkan.h>
#include "Window.h"
#include <vector>
#include <stdexcept>
#include <set>
#include <optional>
#include <iostream>
#include "Pipeline.h"
#include "Material.h"
#include "Mesh.h"
struct QueueFamilyIndices
{
std::optional<uint32_t> graphicsFamily;
std::optional<uint32_t> presentFamily;
bool IsComplete()
{
return graphicsFamily.has_value() && presentFamily.has_value();
}
};
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities;
std::vector<VkSurfaceFormatKHR> formats;
std::vector<VkPresentModeKHR> presentModes;
};
class Renderer
{
public:
Renderer();
~Renderer();
void Initialize(GLFWwindow* window);
void Shutdown();
void BeginFrame();
void EndFrame();
VkDescriptorSetLayout CreateDescriptorSetLayout();
VkDescriptorPool CreateDescriptorPool(uint32_t maxSets);
VkDevice* GetDevice();
VkPhysicalDevice* GetPhysicalDevice();
VkCommandPool* GetCommandPool();
VkQueue* GetGraphicsQueue();
VkCommandBuffer* GetCurrentCommandBuffer();
std::shared_ptr<Pipeline> GetPipeline();
void CreateGraphicsPipeline(Mesh* mesh, Material* material);
private:
bool shutdownInProgress;
uint32_t currentCmdBufferIndex = 0;
std::vector<size_t> currentFramePerImage;
std::vector<VkImage> swapChainImages;
std::vector<VkImageView> swapChainImageViews;
VkExtent2D swapChainExtent;
VkRenderPass renderPass;
uint32_t imageIndex;
std::shared_ptr<Pipeline> pipeline;
VkFormat swapChainImageFormat;
std::vector<VkCommandBuffer> commandBuffers;
void CreateImageViews();
void CleanupImageViews();
void CreateRenderPass();
void CleanupRenderPass();
void CreateSurface();
void DestroySurface();
void CreateInstance();
void CleanupInstance();
void ChoosePhysicalDevice();
void CreateDevice();
void CleanupDevice();
void CreateSwapchain();
void CleanupSwapchain();
void CreateCommandPool();
void CleanupCommandPool();
void CreateFramebuffers();
void CleanupFramebuffers();
void CreateCommandBuffers();
void CleanupCommandBuffers();
void Present();
GLFWwindow* window;
VkInstance instance = VK_NULL_HANDLE;
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
VkDevice device = VK_NULL_HANDLE;
VkSurfaceKHR surface;
VkSwapchainKHR swapchain;
VkCommandPool commandPool;
VkCommandBuffer currentCommandBuffer;
std::vector<VkFramebuffer> framebuffers;
// Additional Vulkan objects needed for rendering…
const uint32_t kMaxFramesInFlight = 2;
std::vector<VkSemaphore> imageAvailableSemaphores;
std::vector<VkSemaphore> renderFinishedSemaphores;
std::vector<VkFence> inFlightFences;
size_t currentFrame;
VkQueue graphicsQueue;
VkQueue presentQueue;
void CreateSyncObjects();
void CleanupSyncObjects();
SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface);
VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats);
VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes);
VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window);
std::vector<const char*> deviceExtensions = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME
};
std::vector<const char*> CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice);
QueueFamilyIndices GetQueueFamilyIndices(VkPhysicalDevice physicalDevice);
};
Renderer.cpp:
#include "Renderer.h"
Renderer::Renderer() : currentFrame(0), shutdownInProgress(false)
{
}
Renderer::~Renderer()
{
Shutdown();
}
void Renderer::Initialize(GLFWwindow* window)
{
this->window = window;
CreateInstance();
CreateSurface();
ChoosePhysicalDevice();
CreateDevice();
CreateSwapchain();
CreateRenderPass();
CreateCommandPool();
CreateFramebuffers();
CreateSyncObjects();
}
void Renderer::Shutdown()
{
if (shutdownInProgress) {
return;
}
shutdownInProgress = true;
if (device != VK_NULL_HANDLE) {
vkDeviceWaitIdle(device);
}
CleanupFramebuffers();
CleanupRenderPass();
CleanupSyncObjects();
CleanupCommandBuffers();
CleanupCommandPool();
CleanupImageViews();
CleanupSwapchain();
if (device != VK_NULL_HANDLE) {
CleanupDevice();
}
DestroySurface();
CleanupInstance();
shutdownInProgress = false;
}
void Renderer::BeginFrame()
{
// Wait for any previous work on this swapchain image to complete
vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
vkResetFences(device, 1, &inFlightFences[currentFrame]);
vkResetCommandBuffer(currentCommandBuffer, 0);
// Acquire an image from the swapchain, then begin recording commands for the current frame.
VkResult acquireResult = vkAcquireNextImageKHR(device, swapchain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
if (acquireResult != VK_SUCCESS && acquireResult != VK_SUBOPTIMAL_KHR) {
throw std::runtime_error("Failed to acquire next swapchain image.");
}
VkCommandBufferBeginInfo beginInfo{};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
currentCmdBufferIndex = (currentCmdBufferIndex + 1) % 2;
currentCommandBuffer = commandBuffers[imageIndex];
// Add debug message before vkBeginCommandBuffer
std::cout << "Current Frame: " << currentFrame << " | Cmd Buffer Index: " << currentCmdBufferIndex << " | Image Index: " << imageIndex << "\n";
std::cout << "Calling vkBeginCommandBuffer…\n";
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
std::cout << "vkBeginCommandBuffer called…\n";
VkRenderPassBeginInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
renderPassInfo.renderPass = renderPass;
renderPassInfo.framebuffer = framebuffers[imageIndex];
renderPassInfo.renderArea.offset = { 0, 0 };
renderPassInfo.renderArea.extent = swapChainExtent;
// Set the clear color to black
VkClearValue clearColor = { 0.0f, 0.0f, 0.0f, 1.0f };
renderPassInfo.clearValueCount = 1;
renderPassInfo.pClearValues = &clearColor;
vkCmdBeginRenderPass(currentCommandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
}
void Renderer::EndFrame()
{
vkCmdEndRenderPass(currentCommandBuffer);
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &imageAvailableSemaphores[currentFrame];
submitInfo.pWaitDstStageMask = waitStages;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = ¤tCommandBuffer;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &renderFinishedSemaphores[currentFrame];
vkEndCommandBuffer(currentCommandBuffer);
vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]);
VkPresentInfoKHR presentInfo{};
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.waitSemaphoreCount = 1;
presentInfo.pWaitSemaphores = &renderFinishedSemaphores[currentFrame];
VkSwapchainKHR swapChains[] = { swapchain };
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = swapChains;
presentInfo.pImageIndices = &imageIndex;
VkResult queuePresentResult = vkQueuePresentKHR(presentQueue, &presentInfo);
std::cout << "Frame rendered: " << currentFrame << "\n";
if (queuePresentResult == VK_ERROR_OUT_OF_DATE_KHR || queuePresentResult == VK_SUBOPTIMAL_KHR) {
// Handle swapchain recreation if needed, e.g., due to resizing the window or other swapchain properties changes
}
else if (queuePresentResult != VK_SUCCESS) {
throw std::runtime_error("Failed to present the swapchain image.");
}
currentFrame = (currentFrame + 1) % kMaxFramesInFlight;
}
void Renderer::CreateSurface()
{
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a window surface.");
}
}
void Renderer::DestroySurface()
{
vkDestroySurfaceKHR(instance, surface, nullptr);
}
void Renderer::CreateInstance()
{
// Set up the application info
VkApplicationInfo appInfo{};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = "Game Engine";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "Game Engine";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_2;
// Set up the instance create info
VkInstanceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;
// Set up the required extensions
uint32_t glfwExtensionCount = 0;
const char** glfwExtensions;
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
createInfo.enabledExtensionCount = glfwExtensionCount;
createInfo.ppEnabledExtensionNames = glfwExtensions;
createInfo.enabledLayerCount = 0;
// Create the Vulkan instance
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create the Vulkan instance.");
}
std::vector<const char*> validationLayers;
#ifdef NDEBUG
const bool enableValidationLayers = false;
#else
const bool enableValidationLayers = true;
validationLayers.push_back("VK_LAYER_KHRONOS_validation");
#endif
if (enableValidationLayers) {
// Check if validation layers are supported
uint32_t layerCount;
vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
std::vector<VkLayerProperties> availableLayers(layerCount);
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
for (const char* layerName : validationLayers) {
bool layerFound = false;
for (const auto& layerProperties : availableLayers) {
if (strcmp(layerName, layerProperties.layerName) == 0) {
layerFound = true;
break;
}
}
if (!layerFound) {
throw std::runtime_error("Validation layer requested, but it’s not available.");
}
}
// Enable the validation layers
createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
createInfo.ppEnabledLayerNames = validationLayers.data();
}
else {
createInfo.enabledLayerCount = 0;
}
}
void Renderer::CleanupInstance()
{
// Destroy the Vulkan instance
vkDestroyInstance(instance, nullptr);
}
void Renderer::ChoosePhysicalDevice()
{
// Enumerate the available physical devices and choose one that supports required features
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
if (deviceCount == 0)
{
throw std::runtime_error("Failed to find a GPU with Vulkan support.");
}
std::vector<VkPhysicalDevice> allDevices(deviceCount);
vkEnumeratePhysicalDevices(instance, &deviceCount, allDevices.data());
for (const auto& testDevice : allDevices)
{
if (glfwGetPhysicalDevicePresentationSupport(instance, testDevice, 0) &&
CheckPhysicalDeviceExtensionSupport(testDevice).empty() &&
GetQueueFamilyIndices(testDevice).IsComplete())
{
physicalDevice = testDevice;
break;
}
}
if (physicalDevice == VK_NULL_HANDLE)
{
throw std::runtime_error("Failed to find a suitable GPU.");
}
}
void Renderer::CreateDevice()
{
// Get the GPU’s queue family indices
const QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
// Set up the device queue create info
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
std::set<uint32_t> uniqueQueueFamilyIndices = { indices.graphicsFamily.value(),indices.presentFamily.value() };
float queuePriority = 1.0f;
for (uint32_t queueFamilyIndex : uniqueQueueFamilyIndices)
{
VkDeviceQueueCreateInfo queueCreateInfo{};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = queueFamilyIndex;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = &queuePriority;
queueCreateInfos.push_back(queueCreateInfo);
}
// Set up the physical device features
VkPhysicalDeviceFeatures deviceFeatures{};
// Set up the device create info
VkDeviceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
createInfo.pQueueCreateInfos = queueCreateInfos.data();
createInfo.pEnabledFeatures = &deviceFeatures;
createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
createInfo.ppEnabledExtensionNames = deviceExtensions.data();
// Create the logical device
if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a logical device.");
}
// Retrieve the graphics queue and the present queue
vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
}
void Renderer::CleanupDevice()
{
// Destroy the logical device
vkDestroyDevice(device, nullptr);
}
void Renderer::CreateSwapchain()
{
// Get swapchain support details
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice,surface);
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
swapChainImageFormat = surfaceFormat.format; // Initialize the swapChainImageFormat
VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities,window);
uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount)
{
imageCount = swapChainSupport.capabilities.maxImageCount;
}
// Create the swapchain
// …
VkSwapchainCreateInfoKHR createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = surface;
createInfo.minImageCount = imageCount;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() };
if (indices.graphicsFamily != indices.presentFamily) {
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
}
else {
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
}
createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapchain) != VK_SUCCESS) {
throw std::runtime_error("failed to create swap chain!");
}
// Retrieve swapchain images (color buffers)
// …
// Retrieve swapchain images
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, nullptr);
swapChainImages.resize(imageCount);
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, swapChainImages.data());
// Create image views for swapchain images
CreateImageViews();
}
void Renderer::CleanupSwapchain()
{
// Clean up Vulkan swapchain
if (swapchain != VK_NULL_HANDLE)
{
vkDestroySwapchainKHR(device, swapchain, nullptr);
swapchain = VK_NULL_HANDLE;
}
}
void Renderer::CreateImageViews()
{
swapChainImageViews.resize(swapChainImages.size());
for (size_t i = 0; i < swapChainImages.size(); ++i)
{
VkImageViewCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
createInfo.image = swapChainImages[i];
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
createInfo.format = swapChainImageFormat;
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
createInfo.subresourceRange.baseMipLevel = 0;
createInfo.subresourceRange.levelCount = 1;
createInfo.subresourceRange.baseArrayLayer = 0;
createInfo.subresourceRange.layerCount = 1;
createInfo.flags = 0;
if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create an image view.");
}
}
}
void Renderer::CleanupImageViews()
{
for (auto imageView : swapChainImageViews)
{
vkDestroyImageView(device, imageView, nullptr);
}
swapChainImageViews.clear();
}
void Renderer::CreateRenderPass()
{
VkAttachmentDescription colorAttachment{};
colorAttachment.format = swapChainImageFormat;
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
VkAttachmentReference colorAttachmentRef{};
colorAttachmentRef.attachment = 0;
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass{};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &colorAttachmentRef;
VkRenderPassCreateInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassInfo.attachmentCount = 1;
renderPassInfo.pAttachments = &colorAttachment;
renderPassInfo.subpassCount = 1;
renderPassInfo.pSubpasses = &subpass;
VkSubpassDependency dependency{};
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
dependency.dstSubpass = 0;
dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.srcAccessMask = 0;
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
renderPassInfo.dependencyCount = 1;
renderPassInfo.pDependencies = &dependency;
if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create render pass.");
}
}
void Renderer::CleanupRenderPass()
{
vkDestroyRenderPass(device, renderPass, nullptr);
}
void Renderer::CreateCommandPool()
{
// Find a queue family index that supports graphics operations
QueueFamilyIndices queueFamilyIndices = GetQueueFamilyIndices(physicalDevice);
// Create a command pool for the queue family
VkCommandPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
poolInfo.flags = 0;
if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create command pool.");
}
CreateCommandBuffers(); // Create command buffers after creating the command pool
}
void Renderer::CleanupCommandPool()
{
// Clean up Vulkan command pool
CleanupCommandBuffers(); // Add this line to clean up command buffers before destroying the command pool
vkDestroyCommandPool(device, commandPool, nullptr);
}
void Renderer::CreateCommandBuffers()
{
commandBuffers.resize(swapChainImages.size());
VkCommandBufferAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.commandPool = commandPool;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandBufferCount = static_cast<uint32_t>(commandBuffers.size());
if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS)
{
throw std::runtime_error("Failed to allocate command buffers.");
}
// Set the initial value of the currentCommandBuffer
currentCommandBuffer = commandBuffers[currentFrame];
}
void Renderer::CleanupCommandBuffers()
{
vkFreeCommandBuffers(device, commandPool, static_cast<uint32_t>(commandBuffers.size()), commandBuffers.data());
}
void Renderer::CreateFramebuffers()
{
// Check if the framebuffers vector is not empty, and call CleanupFramebuffers()
if (!framebuffers.empty()) {
CleanupFramebuffers();
}
// Create Vulkan framebuffers for swapchain images
framebuffers.resize(swapChainImageViews.size());
for (size_t i = 0; i < swapChainImageViews.size(); ++i)
{
VkImageView attachments[] = { swapChainImageViews[i] };
VkFramebufferCreateInfo framebufferInfo{};
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebufferInfo.renderPass = renderPass;
framebufferInfo.attachmentCount = 1;
framebufferInfo.pAttachments = attachments;
framebufferInfo.width = swapChainExtent.width;
framebufferInfo.height = swapChainExtent.height;
framebufferInfo.layers = 1;
if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &framebuffers[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create framebuffer.");
}
}
}
void Renderer::CleanupFramebuffers()
{
for (auto framebuffer : framebuffers)
{
if (framebuffer != VK_NULL_HANDLE)
{
vkDestroyFramebuffer(device, framebuffer, nullptr);
framebuffer = VK_NULL_HANDLE;
}
}
framebuffers.clear(); // Make sure to clear the framebuffers vector after destroying each framebuffer
}
void Renderer::CreateSyncObjects()
{
imageAvailableSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
renderFinishedSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
inFlightFences.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
VkSemaphoreCreateInfo semaphoreInfo{};
semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
VkFenceCreateInfo fenceInfo{};
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS ||
vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS ||
vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create synchronization objects for a frame.");
}
}
}
void Renderer::CleanupSyncObjects()
{
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (renderFinishedSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);
if (imageAvailableSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);
if (inFlightFences[i] != VK_NULL_HANDLE)
vkDestroyFence(device, inFlightFences[i], nullptr);
}
}
SwapChainSupportDetails Renderer::querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface)
{
SwapChainSupportDetails details;
// Query the capabilities
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
// Query the supported formats
uint32_t formatCount;
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
if (formatCount != 0)
{
details.formats.resize(formatCount);
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
}
// Query the supported present modes
uint32_t presentModeCount;
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
if (presentModeCount != 0)
{
details.presentModes.resize(presentModeCount);
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
}
return details;
}
VkSurfaceFormatKHR Renderer::chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats)
{
for (const auto& availableFormat : availableFormats)
{
if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
{
return availableFormat;
}
}
return availableFormats[0];
}
VkPresentModeKHR Renderer::chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes)
{
for (const auto& availablePresentMode : availablePresentModes)
{
if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR)
{
return availablePresentMode;
}
}
return VK_PRESENT_MODE_FIFO_KHR;
}
VkExtent2D Renderer::chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window)
{
if (capabilities.currentExtent.width != UINT32_MAX)
{
return capabilities.currentExtent;
}
else
{
int width, height;
glfwGetFramebufferSize(window, &width, &height);
VkExtent2D actualExtent = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
actualExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, actualExtent.width));
actualExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, actualExtent.height));
return actualExtent;
}
}
std::vector<const char*> Renderer::CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice)
{
uint32_t extensionCount;
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, nullptr);
std::vector<VkExtensionProperties> availableExtensions(extensionCount);
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, availableExtensions.data());
std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
for (const auto& extension : availableExtensions)
{
requiredExtensions.erase(extension.extensionName);
}
std::vector<const char*> remainingExtensions;
for (const auto& extension : requiredExtensions)
{
remainingExtensions.push_back(extension.c_str());
}
return remainingExtensions;
}
QueueFamilyIndices Renderer::GetQueueFamilyIndices(VkPhysicalDevice physicalDevice)
{
QueueFamilyIndices indices;
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr);
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilies.data());
int i = 0;
for (const auto& queueFamily : queueFamilies)
{
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
indices.graphicsFamily = i;
}
VkBool32 presentSupport = false;
vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, surface, &presentSupport);
if (presentSupport)
{
indices.presentFamily = i;
}
if (indices.IsComplete())
{
break;
}
i++;
}
return indices;
}
VkDevice* Renderer::GetDevice() {
return &device;
};
VkPhysicalDevice* Renderer::GetPhysicalDevice() {
return &physicalDevice;
};
VkCommandPool* Renderer::GetCommandPool() {
return &commandPool;
};
VkQueue* Renderer::GetGraphicsQueue() {
return &graphicsQueue;
};
VkCommandBuffer* Renderer::GetCurrentCommandBuffer() {
return ¤tCommandBuffer;
}
VkDescriptorSetLayout Renderer::CreateDescriptorSetLayout() {
VkDescriptorSetLayoutBinding uboLayoutBinding{};
uboLayoutBinding.binding = 0;
uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
uboLayoutBinding.descriptorCount = 1;
uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
uboLayoutBinding.pImmutableSamplers = nullptr;
VkDescriptorSetLayoutCreateInfo layoutInfo{};
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layoutInfo.bindingCount = 1;
layoutInfo.pBindings = &uboLayoutBinding;
VkDescriptorSetLayout descriptorSetLayout;
if (vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &descriptorSetLayout) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor set layout!");
}
return descriptorSetLayout;
}
VkDescriptorPool Renderer::CreateDescriptorPool(uint32_t maxSets) {
VkDescriptorPoolSize poolSize{};
poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
poolSize.descriptorCount = maxSets;
VkDescriptorPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
poolInfo.poolSizeCount = 1;
poolInfo.pPoolSizes = &poolSize;
poolInfo.maxSets = maxSets;
VkDescriptorPool descriptorPool;
if (vkCreateDescriptorPool(device, &poolInfo, nullptr, &descriptorPool) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor pool!");
}
return descriptorPool;
}
void Renderer::CreateGraphicsPipeline(Mesh* mesh, Material* material) {
if (pipeline)
{
pipeline->Cleanup();
}
// Create pipeline object and configure its properties
pipeline = std::make_shared<Pipeline>();
pipeline->CreateGraphicsPipeline(mesh->GetVertexInputBindingDescriptions(),
mesh->GetVertexInputAttributeDescriptions(),
swapChainExtent,
{material->GetvertexShader().get(), material->GetfragmentShader().get()},
renderPass,
material->GetPipelineLayout(),
device);
}
std::shared_ptr<Pipeline> Renderer::GetPipeline() {
return pipeline;
}
The code seems to hang at this line of code in the Renderer::BeginFrame method:
vkResetCommandBuffer(currentCommandBuffer, &0);
I believe it may be due to the use of currentFrame index instead of imageIndex as a means of achieving synchronization. As there is a different number of frames compared to images, this may be causing issue. How can I adjust the code to fix this?
|
4da33397bb3149b4df60bf61d2eebd97
|
{
"intermediate": 0.4038229286670685,
"beginner": 0.3279862403869629,
"expert": 0.268190860748291
}
|
8,920
|
i use try except to catch error in python, but the error has 2 error, and i only able to catch the lastest one, how can catch the first error
|
2bf600e0803d7cc192427549b5d6a8a2
|
{
"intermediate": 0.49697214365005493,
"beginner": 0.09577865153551102,
"expert": 0.40724924206733704
}
|
8,921
|
my case is creating the object into the db table, and it violate the fk of its field, the first error is psycopg2.errors.ForeignKeyViolation, the second is sqlachemy integrity error.
how able the catch the psycopg2.errors.ForeignKeyViolation error?
in fastapi
|
380004c5015b597b0658b57fa5798759
|
{
"intermediate": 0.591762900352478,
"beginner": 0.20916970074176788,
"expert": 0.19906741380691528
}
|
8,922
|
create inherited class of from typing import TypeVar, Generic
from uuid import UUID
from src.db.postgresql_manager import postgresql_manager
INPUT_DTO = TypeVar('INPUT_DTO')
OUTPUT_DTO = TypeVar('OUTPUT_DTO')
ORM_CLASS = TypeVar('ORM_CLASS')
class BaseBusinessLogic(Generic[INPUT_DTO, OUTPUT_DTO, ORM_CLASS]):
async def create_city(self, create_dto: INPUT_DTO) -> OUTPUT_DTO:
create_dto.verify()
orm = ORM_CLASS(**create_dto.dict())
orm = await postgresql_manager.create(ORM_CLASS, orm)
return OUTPUT_DTO.from_orm(orm)
async def read_all(self) -> list[OUTPUT_DTO]:
orm_list = await postgresql_manager.read_all(ORM_CLASS)
return [OUTPUT_DTO.from_orm(orm) for orm in orm_list]
async def read(self, id: UUID) -> OUTPUT_DTO:
orm = await postgresql_manager.read(ORM_CLASS, id)
return OUTPUT_DTO.from_orm(orm)
async def update(self, id: UUID, update_dto: INPUT_DTO) -> OUTPUT_DTO:
update_dto.verify()
updates = update_dto.dict(exclude_unset=True)
orm = await postgresql_manager.update(ORM_CLASS, id, updates)
return OUTPUT_DTO.from_orm(orm)
async def delete(self, id: UUID) -> OUTPUT_DTO:
city_orm = await postgresql_manager.delete(ORM_CLASS, id)
return OUTPUT_DTO.from_orm(city_orm)
|
37c581c41aec9d77ea65364023ce1642
|
{
"intermediate": 0.3691430687904358,
"beginner": 0.4817277491092682,
"expert": 0.14912915229797363
}
|
8,923
|
hello
|
650d2d9a547df77820ea87c8dd9ed521
|
{
"intermediate": 0.32064199447631836,
"beginner": 0.28176039457321167,
"expert": 0.39759764075279236
}
|
8,924
|
from PIL import Image
import os
imgs = []
remimg = ""
noimg = ""
# Set the input and output directories
input_dir = 'T:/Fivem Related/Alpha Dev/Reduce Big Inventory File Sizes for faster loading!/input/'
output_dir = 'T:/Fivem Related/Alpha Dev/Reduce Big Inventory File Sizes for faster loading!/output/'
# Set the maximum width and height for resizing the images
max_size = (145, 124)
# Loop through all files in the input directory
for filename in os.listdir(input_dir):
if filename.endswith('.png'):
# Open the image file and reduce its dimensions and bit depth
if filename in imgs:
with Image.open(input_dir + filename) as img:
img = img.convert('RGBA')
img.thumbnail(max_size)
# Save the image to the output directory with a reduced file size
new_filename = os.path.splitext(filename)[0] + '.png'
img.save(output_dir + new_filename, optimize=True, quality=50)
else:
remimg = remimg + filename + ", "
for file in imgs:
if not os.path.isfile(input_dir + file):
noimg = noimg + file + ", "
print("Unused Images Removed: " + remimg)
print("Images Not Found: " + noimg)
|
49feb3beb4c4e39bf34c9ca6261cc3a7
|
{
"intermediate": 0.3505849242210388,
"beginner": 0.4263434410095215,
"expert": 0.22307167947292328
}
|
8,925
|
I used your code: import time
from binance.client import Client
from binance.enums import *
from binance.exceptions import BinanceAPIException
import pandas as pd
import requests
import json
import numpy as np
import pytz
import datetime as dt
date = dt.datetime.now().strftime("%m/%d/%Y %H:%M:%S")
print(date)
url = "https://api.binance.com/api/v1/time"
t = time.time()*1000
r = requests.get(url)
result = json.loads(r.content)
# API keys and other configuration
API_KEY = 'Y0ReOvKcXm8e3wfIRYlgcdV9UG10M7XqxsGV0H83S8OMH3H3Fym3iqsfIcHDiq92'
API_SECRET = '0u8aMxMXyIy9dQCti8m4AOeSvAGEqugOiIDML4rxVWDx5dzI80TDGNCMOWn4geVg'
client = Client(API_KEY, API_SECRET)
STOP_LOSS_PERCENTAGE = -50
TAKE_PROFIT_PERCENTAGE = 100
MAX_TRADE_QUANTITY_PERCENTAGE = 100
POSITION_SIDE_SHORT = 'SELL'
POSITION_SIDE_LONG = 'BUY'
symbol = 'BTCUSDT'
quantity = 1
order_type = 'MARKET'
leverage = 125
max_trade_quantity_percentage = 1
client = Client(API_KEY, API_SECRET)
def getminutedata(symbol, interval, lookback):
try:
frame = pd.DataFrame(client.get_historical_klines(symbol, interval, lookback+'min ago UTC'))
frame = frame.iloc[:60,:6]
frame.columns = ['Time','Open','High','Low','Close','Volume']
frame = frame.set_index('Time')
today = dt.date.today()
frame.index = pd.to_datetime(frame.index, unit='ms').tz_localize('UTC').tz_convert('Etc/GMT+3').strftime(f"{today} %H:%M:%S")
frame = frame.astype(float)
return frame
except Exception as e:
print(f"Error getting minute data: {str(e)}")
return
df = getminutedata('BTCUSDT', '1m', '44640')
def signal_generator(df):
try:
open = df.Open.iloc[-1]
close = df.Close.iloc[-1]
previous_open = df.Open.iloc[-2]
previous_close = df.Close.iloc[-2]
# Bearish pattern
if (open>close and
previous_open<previous_close and
close<previous_open and
open>=previous_close):
return 'sell'
# Bullish pattern
elif (open<close and
previous_open>previous_close and
close>previous_open and
open<=previous_close):
return 'buy'
# No clear pattern
else:
return ''
except Exception as e:
print(f"Error generating signal: {str(e)}")
return signal_generator(df)
def order_execution(symbol, signal, max_trade_quantity_percentage, leverage):
max_trade_quantity = None
account_balance = client.futures_account_balance()
usdt_balance = float([x['balance'] for x in account_balance if x['asset'] == 'USDT'][0])
max_trade_quantity = usdt_balance * max_trade_quantity_percentage/100
# Close long position if signal is opposite
long_position = None
short_position = None
positions = client.futures_position_information(symbol=symbol)
for p in positions:
if p['positionSide'] == 'LONG':
long_position = p
elif p['positionSide'] == 'SHORT':
short_position = p
if long_position is not None and short_position is not None:
print("Multiple positions found. Closing both positions.")
if long_position is not None:
client.futures_create_order(
symbol=symbol,
side=SIDE_SELL,
type=ORDER_TYPE_MARKET,
quantity=long_position['positionAm’'],
reduceOnly=True
)
time.sleep(1)
if short_position is not None:
client.futures_create_order(
symbol=symbol,
side=SIDE_BUY,
type=ORDER_TYPE_MARKET,
quantity=short_position['positionAmt'],
reduceOnly=True
)
time.sleep(1)
print("Both positions closed.")
if signal == 'buy':
position_side = POSITION_SIDE_LONG
opposite_position = short_position
elif signal == 'sell':
position_side = POSITION_SIDE_SHORT
opposite_position = long_position
else:
print("Invalid signal. No order placed.")
order_quantity = 0
if opposite_position is not None:
order_quantity = min(max_trade_quantity, abs(float(opposite_position['positionAmt'])))
if opposite_position is not None and opposite_position['positionSide'] != position_side:
print("Opposite position found. Closing position before placing order.")
client.futures_create_order(
symbol=symbol,
side=SIDE_SELL if opposite_position['positionSide'] == POSITION_SIDE_LONG else SIDE_BUY,
type=ORDER_TYPE_MARKET,
quantity=order_quantity,
reduceOnly=True
)
time.sleep(1)
# Place the order and capture the returned order ID
order = client.futures_create_order(
symbol=symbol,
side=SIDE_BUY if signal == 'buy' else SIDE_SELL,
type=ORDER_TYPE_MARKET,
quantity=order_quantity,
reduceOnly=False,
timeInForce=TIME_IN_FORCE_GTC,
positionSide=position_side,
leverage=leverage
)
if order is None:
print("Order not placed successfully. Skipping setting stop loss and take profit orders.")
order_id = order['orderId']
print(f"Placed {signal} order with order ID {order_id} and quantity {order_quantity}")
time.sleep(1)
# Set stop loss and take profit orders
# Get the order details to determine the order price
order_info = client.futures_get_order(symbol=symbol, orderId=order_id)
if order_info is None:
print("Error getting order information. Skipping setting stop loss and take profit orders.")
else:
order_price = float(order_info['avgPrice'])
# Set stop loss and take profit orders
stop_loss_price = order_price * (1 + STOP_LOSS_PERCENTAGE / 100) if signal == 'sell' else order_price * (1 - STOP_LOSS_PERCENTAGE / 100)
take_profit_price = order_price * (1 + TAKE_PROFIT_PERCENTAGE / 100) if signal == 'buy' else order_price * (1 - TAKE_PROFIT_PERCENTAGE / 100)
stop_loss_order = client.futures_create_order(
symbol=symbol,
side=SIDE_SELL if signal == 'buy' else SIDE_BUY,
type=ORDER_TYPE_STOP_LOSS,
quantity=order_quantity,
stopPrice=stop_loss_price,
reduceOnly=True,
timeInForce=TIME_IN_FORCE_GTC,
positionSide=position_side
)
take_profit_order = client.futures_create_order(
symbol=symbol,
side=SIDE_SELL if signal == 'buy' else SIDE_BUY,
type=ORDER_TYPE_LIMIT,
quantity=order_quantity,
price=take_profit_price,
reduceOnly=True,
timeInForce=TIME_IN_FORCE_GTC,
positionSide=position_side
)
# Print order creation confirmation messages
print(f"Placed {signal} order with order ID {order_id} and quantity {order_quantity}")
print(f"Placed stop loss order with stop loss price {stop_loss_price}")
print(f"Placed take profit order with take profit price {take_profit_price}")
time.sleep(1)
while True:
current_time = dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
df = getminutedata('BTCUSDT', '1m', '44640') # Get minute data each loop
if df is None:
continue
current_signal = signal_generator(df)
print(f"The signal time is: {current_time} :{current_signal}")
if current_signal:
order_execution('BTCUSDT', current_signal, max_trade_quantity_percentage, leverage)
time.sleep(1) # Add a delay of 1 second But when I getting signal in terminal it showing me ERROR: The signal time is: 2023-05-29 10:33:06 :sell
Both positions closed.
Traceback (most recent call last):
File "c:\Users\Alan\.vscode\jew_bot\jew_bot\jew_bot.py", line 204, in <module>
order_execution('BTCUSDT', current_signal, max_trade_quantity_percentage, leverage)
File "c:\Users\Alan\.vscode\jew_bot\jew_bot\jew_bot.py", line 136, in order_execution
side=SIDE_SELL if opposite_position['positionSide'] == POSITION_SIDE_LONG else SIDE_BUY,
~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^
TypeError: 'NoneType' object is not subscriptable Please give me right code
|
4550f5c97b45ba4ea266876fbbd3a456
|
{
"intermediate": 0.3562747538089752,
"beginner": 0.4917345345020294,
"expert": 0.15199072659015656
}
|
8,926
|
well, the problem here that this 3d cube figure is got centered on its edge, except the actual center of a 3d cube, when you try to resize the canvas and it got auto-scaled. what if you output all the forma controlling parameters at the top, and also add some interesting intriguing function to manipulate all the vertices and edges through some extraterrestrial way known only to aliens. ha-ha.: const canvas = document.createElement('canvas');
canvas.width = window.innerWidth;
canvas.height = window.innerHeight;
document.body.appendChild(canvas);
const ctx = canvas.getContext('2d');
const vertices = [
[0, 0, 0],
[0, 1, 0],
[1, 1, 0],
[1, 0, 0],
[0, 0, 1],
[0, 1, 1],
[1, 1, 1],
[1, 0, 1],
];
const edges = [
[0, 1],
[1, 2],
[2, 3],
[3, 0],
[0, 4],
[1, 5],
[2, 6],
[3, 7],
[4, 5],
[5, 6],
[6, 7],
[7, 4],
];
function rotateX(angle) {
const c = Math.cos(angle);
const s = Math.sin(angle);
return [
[1, 0, 0],
[0, c, -s],
[0, s, c],
];
}
function rotateY(angle) {
const c = Math.cos(angle);
const s = Math.sin(angle);
return [
[c, 0, s],
[0, 1, 0],
[-s, 0, c],
];
}
function rotateZ(angle) {
const c = Math.cos(angle);
const s = Math.sin(angle);
return [
[c, -s, 0],
[s, c, 0],
[0, 0, 1],
];
}
function project(vertex, scale, offsetX, offsetY, zoom) {
const [x, y, z] = vertex;
return [
((x * scale) / (zoom + z) + offsetX),
((y * scale) / (zoom + z) + offsetY),
];
}
function transform(vertex, rotationMatrix) {
const [x, y, z] = vertex;
const [rowX, rowY, rowZ] = rotationMatrix;
return [
x * rowX[0] + y * rowX[1] + z * rowX[2],
x * rowY[0] + y * rowY[1] + z * rowY[2],
x * rowZ[0] + y * rowZ[1] + z * rowZ[2],
];
}
let angleX = 0;
let angleY = 0;
let angleZ = 0;
function render() {
ctx.fillStyle = '#FFF';
ctx.fillRect(0, 0, canvas.width, canvas.height);
const rotX = rotateX(angleX);
const rotY = rotateY(angleY);
const rotZ = rotateZ(angleZ);
const transformedVertices = vertices.map(vertex => {
const cx = vertex[0] - 0.5;
const cy = vertex[1] - 0.5;
const cz = vertex[2] - 0.5;
const rotated = transform(transform(transform([cx, cy, cz], rotX), rotY), rotZ);
return [
rotated[0] + 0.5,
rotated[1] + 0.5,
rotated[2] + 0.5,
];
});
const scale = Math.min(canvas.width, canvas.height) / 4;
const offsetX = canvas.width / 2;
const offsetY = canvas.height / 2;
const zoom = 1;
const projectedVertices = transformedVertices.map(vertex => project(vertex, scale, offsetX, offsetY, zoom));
ctx.strokeStyle = '#000';
ctx.beginPath();
for (let edge of edges) {
const [a, b] = edge;
const [x1, y1] = projectedVertices[a];
const [x2, y2] = projectedVertices[b];
ctx.moveTo(x1, y1);
ctx.lineTo(x2, y2);
}
ctx.stroke();
angleX += 0.01;
angleY += 0.013;
angleZ += 0.007;
requestAnimationFrame(render);
}
requestAnimationFrame(render);
window.addEventListener("resize", () => {
canvas.width = window.innerWidth;
canvas.height = window.innerHeight;
});
|
a608743384fd0553a449346fdaa6fb90
|
{
"intermediate": 0.27485689520835876,
"beginner": 0.498482882976532,
"expert": 0.22666023671627045
}
|
8,927
|
Do you konw halftone of print
|
459be1b65e7bbd6e5af6a77e6e5f38af
|
{
"intermediate": 0.29614734649658203,
"beginner": 0.4402962028980255,
"expert": 0.26355642080307007
}
|
8,928
|
write blender python script to send mesh to unreal engine in realtime
|
2653cab1e8c73992e6754e5cde834c7a
|
{
"intermediate": 0.36852172017097473,
"beginner": 0.14627377688884735,
"expert": 0.4852045476436615
}
|
8,929
|
Do you konw lut
|
7e4ceaf5d727e4e012844f0e03b95422
|
{
"intermediate": 0.31812959909439087,
"beginner": 0.32987087965011597,
"expert": 0.35199952125549316
}
|
8,930
|
Memory* match (int* page, int memoryCapacity, int index, Memory* front){
//as the front node of duplication memory queue
Memory* newNode = (Memory*)malloc(sizeof (Memory));
newNode -> pageindex = front ->pageindex;
newNode->next = NULL;
Memory *frontduplication = newNode;
// to change the dup queue
Memory *curr = frontduplication;
Memory *p = front->next;
//doing duplicate
while(p){
newNode = (Memory *)malloc(sizeof(Memory));
newNode->pageindex = p->pageindex;
newNode->next = NULL;
curr->next = newNode;
curr = curr->next;
p = p->next;
}
int count = 0;
for (size_t i = index; i < STREAM_SIZE; i++)
{
if(page[i] == frontduplication->pageindex){
Memory *p = frontduplication;
frontduplication = frontduplication->next;
free(p);
count++;
if (memoryCapacity - count == 1){
return frontduplication;
}
continue;
}
else {
Memory *pre = frontduplication;
curr = frontduplication->next;
while (curr){
if(page[i] == curr->pageindex){
Memory *p = curr;
curr = curr->next;
pre->next = curr;
free(p);
count++;
if (memoryCapacity - count == 1){
return pre;
}
}
curr = curr->next;
pre = pre->next;
}
}
return frontduplication;
}
}
void OPT(int *page,int memoryCapacity){
double hitrate = 0.0;
Memory* front = NULL;
Memory* rear = NULL;
int miss = 0;
int count = 0;
for(int i = 0; i < STREAM_SIZE; i++){
// ERROR !! i put the initialization code of "curr" out of the loop!
Memory *curr = front;
while (curr){
if (page[i] == curr->pageindex ){
break;
}
else {
curr = curr->next;
}
}
if(curr == NULL){// page not in memory
miss++;// not hit
//new a node
Memory *newNode = (Memory*)malloc(sizeof(Memory));
newNode->pageindex = page[i];
newNode ->next = NULL;
if(count == memoryCapacity){
//find the page which will move out
if(match(page, memoryCapacity, i, front) == front){
Memory *p = front;
newNode->next = front->next;
front = newNode;
free(p);
}
else {
Memory *pre = front;
while (pre->next == match(page, memoryCapacity, i, front))
{
pre = pre->next;
}
Memory *p = match(page, memoryCapacity, i, front);
pre->next = newNode;
newNode->next = p->next;
free(p);
}
}
else if (count == 0 ){
front = rear = newNode;
count++;
}
else {
rear->next = newNode;
rear = newNode;
count++;
}
}
}
hitrate = 1 -((double) miss/320);
printf("the hit rate of OPT is %f\n",hitrate);
}哪里有问题？
|
7b518524a020256730590a7292f8af55
|
{
"intermediate": 0.30806049704551697,
"beginner": 0.35888299345970154,
"expert": 0.33305659890174866
}
|
8,931
|
how to use with .. as to open two files in python?
|
7ccb2994dbc7bd7586ef9463ef4e2404
|
{
"intermediate": 0.6108680963516235,
"beginner": 0.1514841467142105,
"expert": 0.23764780163764954
}
|
8,932
|
fix this code and save switches state in ./configs/pref.json and load it when app starts #Functions
#silent.configure(command=save_config(silent.get(),theme.get()))
app.mainloop()
def write_config():
path = os.getcwd()+"configs"
with open(path, "w") as jsonfile:
json.dump(config, jsonfile)
print("Updated configuration written to config.json")
if __name__ == '__main__':
APP()
|
07bb9c96f2c841ce5d1e1f64649f7f71
|
{
"intermediate": 0.35870227217674255,
"beginner": 0.5039096474647522,
"expert": 0.13738805055618286
}
|
8,933
|
const computedValues = cleanedQuotes.reduce(
(
acc: Array<Omit<ItemRegionalMean, "createdAt" | "updatedAt">>,
itemQuotes,
index
) => {
if (itemQuotes.length > 0) {
let product = 1;
let count = 0;
let min = itemQuotes[0].price.toNumber();
let max = itemQuotes[0].price.toNumber();
for (const quote of itemQuotes) {
const price = quote.price.toNumber();
if (price > 0) {
product *= price;
min = Math.min(min, price);
max = Math.max(max, price);
count++;
} else {
console.error(`Price is 0 for quote ${quote.quoteId} `);
}
}
const geomean = Math.pow(product, 1 / count);
if (geomean === 0) return acc;
const stdev = Math.sqrt(
itemQuotes.reduce((sum: number, quote) => {
if (quote.price.toNumber() > 0)
sum += Math.pow(quote.price.toNumber() - geomean, 2);
return sum;
}, 0) / count
);
console.log(
`stdev: ${stdev}, geomean: ${geomean}, count: ${count}`
);
const variation = stdev / geomean;
if (itemQuotes.length > 0 && geomean > 0) {
acc.push({
itemCode: itemQuotes[0].quotation.itemCode,
geomean: new Prisma.Decimal(geomean),
stdev: new Prisma.Decimal(stdev),
variation: new Prisma.Decimal(variation),
min: new Prisma.Decimal(min),
max: new Prisma.Decimal(max),
regionCode,
questionnaireId,
});
}
} else {
console.error("No clean quotes for item: ", items[index].code);
}
return acc;
},
[]
);
console.log(
"Clean quotes: ",
JSON.stringify(cleanedQuotes, null, 4),
"\ncomputed: ",
JSON.stringify(computedValues, null, 4)
); what does the above code do ? and also check if variation isnt being calculated correctly
|
631bdc57a73b4a198b7821a52cb7172e
|
{
"intermediate": 0.30128368735313416,
"beginner": 0.41284269094467163,
"expert": 0.2858735918998718
}
|
8,934
|
I’m building a video game engine using C++ as the coding language and Vulkan for graphics. I am trying to set up a generic renderer using Vulkan that is flexible and will render objects based on a vector that is supplied to it. The renderer will also handle the creation of the window using GLFW and use GLM for all relevant math calls. I am using the ASSIMP library to load 3d models and animations.
Here is a portion of the code:
Renderer.h:
#pragma once
#include <vulkan/vulkan.h>
#include "Window.h"
#include <vector>
#include <stdexcept>
#include <set>
#include <optional>
#include <iostream>
#include "Pipeline.h"
#include "Material.h"
#include "Mesh.h"
struct QueueFamilyIndices
{
std::optional<uint32_t> graphicsFamily;
std::optional<uint32_t> presentFamily;
bool IsComplete()
{
return graphicsFamily.has_value() && presentFamily.has_value();
}
};
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities;
std::vector<VkSurfaceFormatKHR> formats;
std::vector<VkPresentModeKHR> presentModes;
};
class Renderer
{
public:
Renderer();
~Renderer();
void Initialize(GLFWwindow* window);
void Shutdown();
void BeginFrame();
void EndFrame();
VkDescriptorSetLayout CreateDescriptorSetLayout();
VkDescriptorPool CreateDescriptorPool(uint32_t maxSets);
VkDevice* GetDevice();
VkPhysicalDevice* GetPhysicalDevice();
VkCommandPool* GetCommandPool();
VkQueue* GetGraphicsQueue();
VkCommandBuffer* GetCurrentCommandBuffer();
std::shared_ptr<Pipeline> GetPipeline();
void CreateGraphicsPipeline(Mesh* mesh, Material* material);
private:
bool shutdownInProgress;
uint32_t currentCmdBufferIndex = 0;
std::vector<VkImage> swapChainImages;
std::vector<VkImageView> swapChainImageViews;
VkExtent2D swapChainExtent;
VkRenderPass renderPass;
uint32_t imageIndex;
std::shared_ptr<Pipeline> pipeline;
VkFormat swapChainImageFormat;
std::vector<VkCommandBuffer> commandBuffers;
void CreateImageViews();
void CleanupImageViews();
void CreateRenderPass();
void CleanupRenderPass();
void CreateSurface();
void DestroySurface();
void CreateInstance();
void CleanupInstance();
void ChoosePhysicalDevice();
void CreateDevice();
void CleanupDevice();
void CreateSwapchain();
void CleanupSwapchain();
void CreateCommandPool();
void CleanupCommandPool();
void CreateFramebuffers();
void CleanupFramebuffers();
void CreateCommandBuffers();
void CleanupCommandBuffers();
GLFWwindow* window;
VkInstance instance = VK_NULL_HANDLE;
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
VkDevice device = VK_NULL_HANDLE;
VkSurfaceKHR surface;
VkSwapchainKHR swapchain;
VkCommandPool commandPool;
VkCommandBuffer currentCommandBuffer;
std::vector<VkFramebuffer> framebuffers;
// Additional Vulkan objects needed for rendering…
const uint32_t kMaxFramesInFlight = 2;
std::vector<VkSemaphore> imageAvailableSemaphores;
std::vector<VkSemaphore> renderFinishedSemaphores;
std::vector<VkFence> inFlightFences;
size_t currentFrame;
VkQueue graphicsQueue;
VkQueue presentQueue;
void CreateSyncObjects();
void CleanupSyncObjects();
SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface);
VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats);
VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes);
VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window);
std::vector<const char*> deviceExtensions = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME
};
std::vector<const char*> CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice);
QueueFamilyIndices GetQueueFamilyIndices(VkPhysicalDevice physicalDevice);
};
Renderer.cpp:
#include "Renderer.h"
Renderer::Renderer() : currentFrame(0), shutdownInProgress(false)
{
}
Renderer::~Renderer()
{
Shutdown();
}
void Renderer::Initialize(GLFWwindow* window)
{
this->window = window;
CreateInstance();
CreateSurface();
ChoosePhysicalDevice();
CreateDevice();
CreateSwapchain();
CreateRenderPass();
CreateCommandPool();
CreateFramebuffers();
CreateSyncObjects();
}
void Renderer::Shutdown()
{
if (shutdownInProgress) {
return;
}
shutdownInProgress = true;
if (device != VK_NULL_HANDLE) {
vkDeviceWaitIdle(device);
}
CleanupFramebuffers();
CleanupRenderPass();
CleanupSyncObjects();
CleanupCommandBuffers();
CleanupCommandPool();
CleanupImageViews();
CleanupSwapchain();
if (device != VK_NULL_HANDLE) {
CleanupDevice();
}
DestroySurface();
CleanupInstance();
shutdownInProgress = false;
}
void Renderer::BeginFrame()
{
// Wait for any previous work on this swapchain image to complete
vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
vkResetFences(device, 1, &inFlightFences[currentFrame]);
// Acquire an image from the swapchain, then begin recording commands for the current frame.
VkResult acquireResult = vkAcquireNextImageKHR(device, swapchain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
if (acquireResult != VK_SUCCESS && acquireResult != VK_SUBOPTIMAL_KHR) {
throw std::runtime_error("Failed to acquire next swapchain image.");
}
VkCommandBufferBeginInfo beginInfo{};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
//currentCommandBuffer = commandBuffers[currentFrame];
currentCmdBufferIndex = (currentCmdBufferIndex + 1) % 2;
currentCommandBuffer = commandBuffers[currentFrame * 2 + currentCmdBufferIndex];
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
VkRenderPassBeginInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
renderPassInfo.renderPass = renderPass;
renderPassInfo.framebuffer = framebuffers[imageIndex];
renderPassInfo.renderArea.offset = { 0, 0 };
renderPassInfo.renderArea.extent = swapChainExtent;
// Set the clear color to black
VkClearValue clearColor = { 0.0f, 0.0f, 0.0f, 1.0f };
renderPassInfo.clearValueCount = 1;
renderPassInfo.pClearValues = &clearColor;
vkCmdBeginRenderPass(currentCommandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
}
void Renderer::EndFrame()
{
vkCmdEndRenderPass(currentCommandBuffer);
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &imageAvailableSemaphores[currentFrame];
submitInfo.pWaitDstStageMask = waitStages;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = ¤tCommandBuffer;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &renderFinishedSemaphores[currentFrame];
vkEndCommandBuffer(currentCommandBuffer);
vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]);
VkPresentInfoKHR presentInfo{};
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.waitSemaphoreCount = 1;
presentInfo.pWaitSemaphores = &renderFinishedSemaphores[currentFrame];
VkSwapchainKHR swapChains[] = { swapchain };
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = swapChains;
presentInfo.pImageIndices = &imageIndex;
VkResult queuePresentResult = vkQueuePresentKHR(presentQueue, &presentInfo);
if (queuePresentResult == VK_ERROR_OUT_OF_DATE_KHR || queuePresentResult == VK_SUBOPTIMAL_KHR) {
// Handle swapchain recreation if needed, e.g., due to resizing the window or other swapchain properties changes
}
else if (queuePresentResult != VK_SUCCESS) {
throw std::runtime_error("Failed to present the swapchain image.");
}
currentFrame = (currentFrame + 1) % kMaxFramesInFlight;
}
void Renderer::CreateSurface()
{
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a window surface.");
}
}
void Renderer::DestroySurface()
{
vkDestroySurfaceKHR(instance, surface, nullptr);
}
void Renderer::CreateInstance()
{
// Set up the application info
VkApplicationInfo appInfo{};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = "Game Engine";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "Game Engine";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_2;
// Set up the instance create info
VkInstanceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pApplicationInfo = &appInfo;
// Set up the required extensions
uint32_t glfwExtensionCount = 0;
const char** glfwExtensions;
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
createInfo.enabledExtensionCount = glfwExtensionCount;
createInfo.ppEnabledExtensionNames = glfwExtensions;
createInfo.enabledLayerCount = 0;
// Create the Vulkan instance
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create the Vulkan instance.");
}
}
void Renderer::CleanupInstance()
{
// Destroy the Vulkan instance
vkDestroyInstance(instance, nullptr);
}
void Renderer::ChoosePhysicalDevice()
{
// Enumerate the available physical devices and choose one that supports required features
uint32_t deviceCount = 0;
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
if (deviceCount == 0)
{
throw std::runtime_error("Failed to find a GPU with Vulkan support.");
}
std::vector<VkPhysicalDevice> allDevices(deviceCount);
vkEnumeratePhysicalDevices(instance, &deviceCount, allDevices.data());
for (const auto& testDevice : allDevices)
{
if (glfwGetPhysicalDevicePresentationSupport(instance, testDevice, 0) &&
CheckPhysicalDeviceExtensionSupport(testDevice).empty() &&
GetQueueFamilyIndices(testDevice).IsComplete())
{
physicalDevice = testDevice;
break;
}
}
if (physicalDevice == VK_NULL_HANDLE)
{
throw std::runtime_error("Failed to find a suitable GPU.");
}
}
void Renderer::CreateDevice()
{
// Get the GPU’s queue family indices
const QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
// Set up the device queue create info
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
std::set<uint32_t> uniqueQueueFamilyIndices = { indices.graphicsFamily.value(),indices.presentFamily.value() };
float queuePriority = 1.0f;
for (uint32_t queueFamilyIndex : uniqueQueueFamilyIndices)
{
VkDeviceQueueCreateInfo queueCreateInfo{};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = queueFamilyIndex;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = &queuePriority;
queueCreateInfos.push_back(queueCreateInfo);
}
// Set up the physical device features
VkPhysicalDeviceFeatures deviceFeatures{};
// Set up the device create info
VkDeviceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
createInfo.pQueueCreateInfos = queueCreateInfos.data();
createInfo.pEnabledFeatures = &deviceFeatures;
createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
createInfo.ppEnabledExtensionNames = deviceExtensions.data();
// Create the logical device
if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create a logical device.");
}
// Retrieve the graphics queue and the present queue
vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
}
void Renderer::CleanupDevice()
{
// Destroy the logical device
vkDestroyDevice(device, nullptr);
}
void Renderer::CreateSwapchain()
{
// Get swapchain support details
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice,surface);
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
swapChainImageFormat = surfaceFormat.format; // Initialize the swapChainImageFormat
VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities,window);
uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount)
{
imageCount = swapChainSupport.capabilities.maxImageCount;
}
// Create the swapchain
// …
VkSwapchainCreateInfoKHR createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = surface;
createInfo.minImageCount = imageCount;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() };
if (indices.graphicsFamily != indices.presentFamily) {
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
}
else {
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
}
createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapchain) != VK_SUCCESS) {
throw std::runtime_error("failed to create swap chain!");
}
// Retrieve swapchain images (color buffers)
// …
// Retrieve swapchain images
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, nullptr);
swapChainImages.resize(imageCount);
vkGetSwapchainImagesKHR(device, swapchain, &imageCount, swapChainImages.data());
// Create image views for swapchain images
CreateImageViews();
}
void Renderer::CleanupSwapchain()
{
// Clean up Vulkan swapchain
if (swapchain != VK_NULL_HANDLE)
{
vkDestroySwapchainKHR(device, swapchain, nullptr);
swapchain = VK_NULL_HANDLE;
}
}
void Renderer::CreateImageViews()
{
swapChainImageViews.resize(swapChainImages.size());
for (size_t i = 0; i < swapChainImages.size(); ++i)
{
VkImageViewCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
createInfo.image = swapChainImages[i];
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
createInfo.format = swapChainImageFormat;
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
createInfo.subresourceRange.baseMipLevel = 0;
createInfo.subresourceRange.levelCount = 1;
createInfo.subresourceRange.baseArrayLayer = 0;
createInfo.subresourceRange.layerCount = 1;
createInfo.flags = 0;
if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create an image view.");
}
}
}
void Renderer::CleanupImageViews()
{
for (auto imageView : swapChainImageViews)
{
vkDestroyImageView(device, imageView, nullptr);
}
swapChainImageViews.clear();
}
void Renderer::CreateRenderPass()
{
VkAttachmentDescription colorAttachment{};
colorAttachment.format = swapChainImageFormat;
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
VkAttachmentReference colorAttachmentRef{};
colorAttachmentRef.attachment = 0;
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass{};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &colorAttachmentRef;
VkRenderPassCreateInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassInfo.attachmentCount = 1;
renderPassInfo.pAttachments = &colorAttachment;
renderPassInfo.subpassCount = 1;
renderPassInfo.pSubpasses = &subpass;
VkSubpassDependency dependency{};
dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
dependency.dstSubpass = 0;
dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.srcAccessMask = 0;
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
renderPassInfo.dependencyCount = 1;
renderPassInfo.pDependencies = &dependency;
if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create render pass.");
}
}
void Renderer::CleanupRenderPass()
{
vkDestroyRenderPass(device, renderPass, nullptr);
}
void Renderer::CreateCommandPool()
{
// Find a queue family index that supports graphics operations
QueueFamilyIndices queueFamilyIndices = GetQueueFamilyIndices(physicalDevice);
// Create a command pool for the queue family
VkCommandPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
poolInfo.flags = 0;
if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create command pool.");
}
CreateCommandBuffers(); // Create command buffers after creating the command pool
}
void Renderer::CleanupCommandPool()
{
// Clean up Vulkan command pool
CleanupCommandBuffers(); // Add this line to clean up command buffers before destroying the command pool
vkDestroyCommandPool(device, commandPool, nullptr);
}
void Renderer::CreateCommandBuffers()
{
//commandBuffers.resize(kMaxFramesInFlight);
commandBuffers.resize(kMaxFramesInFlight * 2);
VkCommandBufferAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.commandPool = commandPool;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandBufferCount = static_cast<uint32_t>(commandBuffers.size());
if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS)
{
throw std::runtime_error("Failed to allocate command buffers.");
}
// Set the initial value of the currentCommandBuffer
currentCommandBuffer = commandBuffers[currentFrame];
}
void Renderer::CleanupCommandBuffers()
{
vkFreeCommandBuffers(device, commandPool, static_cast<uint32_t>(commandBuffers.size()), commandBuffers.data());
}
void Renderer::CreateFramebuffers()
{
// Check if the framebuffers vector is not empty, and call CleanupFramebuffers()
if (!framebuffers.empty()) {
CleanupFramebuffers();
}
// Create Vulkan framebuffers for swapchain images
framebuffers.resize(swapChainImageViews.size());
for (size_t i = 0; i < swapChainImageViews.size(); ++i)
{
VkImageView attachments[] = { swapChainImageViews[i] };
VkFramebufferCreateInfo framebufferInfo{};
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebufferInfo.renderPass = renderPass;
framebufferInfo.attachmentCount = 1;
framebufferInfo.pAttachments = attachments;
framebufferInfo.width = swapChainExtent.width;
framebufferInfo.height = swapChainExtent.height;
framebufferInfo.layers = 1;
if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &framebuffers[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create framebuffer.");
}
}
}
void Renderer::CleanupFramebuffers()
{
for (auto framebuffer : framebuffers)
{
if (framebuffer != VK_NULL_HANDLE)
{
vkDestroyFramebuffer(device, framebuffer, nullptr);
framebuffer = VK_NULL_HANDLE;
}
}
framebuffers.clear(); // Make sure to clear the framebuffers vector after destroying each framebuffer
}
void Renderer::CreateSyncObjects()
{
imageAvailableSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
renderFinishedSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
inFlightFences.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
VkSemaphoreCreateInfo semaphoreInfo{};
semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
VkFenceCreateInfo fenceInfo{};
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS ||
vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS ||
vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS)
{
throw std::runtime_error("Failed to create synchronization objects for a frame.");
}
}
}
void Renderer::CleanupSyncObjects()
{
for (size_t i = 0; i < kMaxFramesInFlight; ++i)
{
if (renderFinishedSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);
if (imageAvailableSemaphores[i] != VK_NULL_HANDLE)
vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);
if (inFlightFences[i] != VK_NULL_HANDLE)
vkDestroyFence(device, inFlightFences[i], nullptr);
}
}
SwapChainSupportDetails Renderer::querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface)
{
SwapChainSupportDetails details;
// Query the capabilities
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
// Query the supported formats
uint32_t formatCount;
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
if (formatCount != 0)
{
details.formats.resize(formatCount);
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
}
// Query the supported present modes
uint32_t presentModeCount;
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
if (presentModeCount != 0)
{
details.presentModes.resize(presentModeCount);
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
}
return details;
}
VkSurfaceFormatKHR Renderer::chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats)
{
for (const auto& availableFormat : availableFormats)
{
if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
{
return availableFormat;
}
}
return availableFormats[0];
}
VkPresentModeKHR Renderer::chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes)
{
for (const auto& availablePresentMode : availablePresentModes)
{
if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR)
{
return availablePresentMode;
}
}
return VK_PRESENT_MODE_FIFO_KHR;
}
VkExtent2D Renderer::chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window)
{
if (capabilities.currentExtent.width != UINT32_MAX)
{
return capabilities.currentExtent;
}
else
{
int width, height;
glfwGetFramebufferSize(window, &width, &height);
VkExtent2D actualExtent = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
actualExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, actualExtent.width));
actualExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, actualExtent.height));
return actualExtent;
}
}
std::vector<const char*> Renderer::CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice)
{
uint32_t extensionCount;
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, nullptr);
std::vector<VkExtensionProperties> availableExtensions(extensionCount);
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, availableExtensions.data());
std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
for (const auto& extension : availableExtensions)
{
requiredExtensions.erase(extension.extensionName);
}
std::vector<const char*> remainingExtensions;
for (const auto& extension : requiredExtensions)
{
remainingExtensions.push_back(extension.c_str());
}
return remainingExtensions;
}
QueueFamilyIndices Renderer::GetQueueFamilyIndices(VkPhysicalDevice physicalDevice)
{
QueueFamilyIndices indices;
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr);
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilies.data());
int i = 0;
for (const auto& queueFamily : queueFamilies)
{
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
indices.graphicsFamily = i;
}
VkBool32 presentSupport = false;
vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, surface, &presentSupport);
if (presentSupport)
{
indices.presentFamily = i;
}
if (indices.IsComplete())
{
break;
}
i++;
}
return indices;
}
VkDevice* Renderer::GetDevice() {
return &device;
};
VkPhysicalDevice* Renderer::GetPhysicalDevice() {
return &physicalDevice;
};
VkCommandPool* Renderer::GetCommandPool() {
return &commandPool;
};
VkQueue* Renderer::GetGraphicsQueue() {
return &graphicsQueue;
};
VkCommandBuffer* Renderer::GetCurrentCommandBuffer() {
return ¤tCommandBuffer;
}
VkDescriptorSetLayout Renderer::CreateDescriptorSetLayout() {
VkDescriptorSetLayoutBinding uboLayoutBinding{};
uboLayoutBinding.binding = 0;
uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
uboLayoutBinding.descriptorCount = 1;
uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
uboLayoutBinding.pImmutableSamplers = nullptr;
VkDescriptorSetLayoutCreateInfo layoutInfo{};
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layoutInfo.bindingCount = 1;
layoutInfo.pBindings = &uboLayoutBinding;
VkDescriptorSetLayout descriptorSetLayout;
if (vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &descriptorSetLayout) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor set layout!");
}
return descriptorSetLayout;
}
VkDescriptorPool Renderer::CreateDescriptorPool(uint32_t maxSets) {
VkDescriptorPoolSize poolSize{};
poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
poolSize.descriptorCount = maxSets;
VkDescriptorPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
poolInfo.poolSizeCount = 1;
poolInfo.pPoolSizes = &poolSize;
poolInfo.maxSets = maxSets;
VkDescriptorPool descriptorPool;
if (vkCreateDescriptorPool(device, &poolInfo, nullptr, &descriptorPool) != VK_SUCCESS) {
throw std::runtime_error("Failed to create descriptor pool!");
}
return descriptorPool;
}
void Renderer::CreateGraphicsPipeline(Mesh* mesh, Material* material) {
if (pipeline)
{
pipeline->Cleanup();
}
// Create pipeline object and configure its properties
pipeline = std::make_shared<Pipeline>();
pipeline->CreateGraphicsPipeline(mesh->GetVertexInputBindingDescriptions(),
mesh->GetVertexInputAttributeDescriptions(),
swapChainExtent,
{material->GetvertexShader().get(), material->GetfragmentShader().get()},
renderPass,
material->GetPipelineLayout(),
device);
}
std::shared_ptr<Pipeline> Renderer::GetPipeline() {
return pipeline;
}
The code seems to hang at this line of code in the Renderer::BeginFrame method:
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
It does this after renderering several frames, but then just stops progressing past this line. Any ideas of what the issue could be?
|
ffe132d8e2eb05bec846a5b675acc541
|
{
"intermediate": 0.32107990980148315,
"beginner": 0.3840792775154114,
"expert": 0.29484084248542786
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.