Xenthera
e23be1cd58
Image class is just array of palette indices converted from the rgb data of any image by using euclidian distance between palette rgb and pixel rgb. Works well.
579 lines
18 KiB
C++
579 lines
18 KiB
C++
//
|
|
// Created by Bobby Lucero on 4/20/24.
|
|
//
|
|
|
|
#include "Graphics.h"
|
|
#include "PycronImage.h"
|
|
#include "Font.h"
|
|
#include "../Utilities.h"
|
|
#include "../StateManager.h"
|
|
|
|
#include <fstream>
|
|
#include <raymath.h>
|
|
|
|
|
|
|
|
|
|
Graphics::Graphics(int screenWidth, int screenHeight, int startupScale) : m_screenWidth(screenWidth), m_screenHeight(screenHeight){
|
|
|
|
m_NormalFont = new PixelFont(5, 7, "resources/fonts/main.font");
|
|
m_currentFont = m_NormalFont;
|
|
|
|
m_startupScreenWidth = screenWidth * startupScale;
|
|
m_startupScreenHeight = screenHeight * startupScale;
|
|
m_windowWidth = m_startupScreenWidth;
|
|
m_windowHeight = m_startupScreenHeight;
|
|
|
|
SetConfigFlags(FLAG_WINDOW_RESIZABLE);
|
|
InitWindow(m_startupScreenWidth, m_startupScreenHeight, "test");
|
|
SetTargetFPS(60);
|
|
|
|
m_virtualScreen = LoadRenderTexture(screenWidth, screenHeight);
|
|
m_origin = {0,0};
|
|
m_virtualScreenLocalBounds = {0.0f, 0.0f, (float)m_virtualScreen.texture.width, (float)m_virtualScreen.texture.height };
|
|
m_virtualScreenWindowBounds = {0.0f, 0.0f, (float)m_windowWidth, (float)m_windowHeight};
|
|
|
|
m_virtualScreenImageBuffer = GenImageColor(m_screenWidth, m_screenHeight, BLACK);
|
|
m_virtualScreenColorBuffer = {};
|
|
m_virtualScreenColorBuffer.resize(screenWidth * screenHeight);
|
|
|
|
calculateScreenPositionInWindow();
|
|
|
|
}
|
|
|
|
Graphics::~Graphics() {
|
|
delete m_NormalFont;
|
|
m_NormalFont = nullptr;
|
|
m_currentFont = nullptr;
|
|
}
|
|
|
|
void Graphics::draw(StateManager* stateManager) {
|
|
m_windowShouldClose = WindowShouldClose();
|
|
|
|
if (IsWindowResized()) {
|
|
m_windowWidth = GetScreenWidth();
|
|
m_windowHeight = GetScreenHeight();
|
|
calculateScreenPositionInWindow();
|
|
}
|
|
|
|
stateManager->Draw();
|
|
copyBufferToGPU();
|
|
renderVirtualScreen();
|
|
}
|
|
|
|
void Graphics::copyBufferToGPU() {
|
|
Color* pixel_data = LoadImageColors(m_virtualScreenImageBuffer);
|
|
for (int i = 0; i < m_screenWidth * m_screenHeight; ++i) {
|
|
pixel_data[i] = GetColor(m_paletteByID[m_virtualScreenColorBuffer[i]]);
|
|
}
|
|
UpdateTexture(m_virtualScreen.texture, pixel_data);
|
|
UnloadImageColors(pixel_data);
|
|
}
|
|
|
|
void Graphics::renderVirtualScreen() {
|
|
BeginDrawing();
|
|
ClearBackground(BLACK);
|
|
DrawTexturePro(m_virtualScreen.texture, m_virtualScreenLocalBounds, m_virtualScreenWindowBounds, m_origin, 0.0f, WHITE);
|
|
DrawText(std::to_string(GetFPS()).c_str(), 10, 10, 30, YELLOW);
|
|
|
|
EndDrawing();
|
|
}
|
|
|
|
void Graphics::loadPalette(std::string path) {
|
|
std::ifstream paletteFile(path);
|
|
std::string line;
|
|
|
|
if(paletteFile.is_open()){
|
|
int idx = 0;
|
|
while(getline(paletteFile, line)){
|
|
int color = stoi(line, nullptr, 16);
|
|
//Palette.push_back();
|
|
color = color << 8 | 0xFF;
|
|
m_paletteByID.insert({idx, color});
|
|
idx++;
|
|
}
|
|
paletteFile.close();
|
|
}
|
|
}
|
|
|
|
void Graphics::calculateScreenPositionInWindow() {
|
|
float virtualAspectRatio = (float)m_screenWidth / (float)m_screenHeight;
|
|
float windowAspectRatio = (float)m_windowWidth / (float)m_windowHeight;
|
|
|
|
if(windowAspectRatio > virtualAspectRatio) {
|
|
m_virtualScreenWindowBounds.height = (float)m_windowHeight;
|
|
m_virtualScreenWindowBounds.width = m_virtualScreenWindowBounds.height * virtualAspectRatio;
|
|
m_origin.x = -(m_windowWidth / 2.0f - (m_virtualScreenWindowBounds.width / 2.0f));
|
|
m_origin.y = 0;
|
|
}else {
|
|
m_virtualScreenWindowBounds.width = (float)m_windowWidth;
|
|
m_virtualScreenWindowBounds.height = m_virtualScreenWindowBounds.width / virtualAspectRatio;
|
|
m_origin.x = 0;
|
|
m_origin.y = -(m_windowHeight / 2.0f - (m_virtualScreenWindowBounds.height / 2.0f));
|
|
}
|
|
}
|
|
|
|
int Graphics::rgbToID(int r, int g, int b) {
|
|
r = Clamp(r, 0, 255);
|
|
g = Clamp(g, 0, 255);
|
|
b = Clamp(b, 0, 255);
|
|
uint8_t idx = 0;
|
|
Color c = GetColor(m_paletteByID[idx]);
|
|
double minDist = std::pow(r - c.r, 2) +
|
|
std::pow(g - c.g, 2) +
|
|
std::pow(b - c.b, 2);
|
|
|
|
for(const auto& paletteColor : m_paletteByID){
|
|
c = GetColor(paletteColor.second);
|
|
double dist = std::pow(r - c.r, 2) +
|
|
std::pow(g - c.g, 2) +
|
|
std::pow(b - c.b, 2);
|
|
if(dist < minDist){
|
|
minDist = dist;
|
|
idx = paletteColor.first;
|
|
}
|
|
}
|
|
|
|
return idx;
|
|
}
|
|
|
|
int Graphics::mouseX() {
|
|
float x = GetMouseX();
|
|
float adjX = x + m_origin.x;
|
|
return (int)(adjX / m_virtualScreenWindowBounds.width * m_screenWidth);
|
|
}
|
|
|
|
int Graphics::mouseY() {
|
|
float y = GetMouseY();
|
|
float adjY = y + m_origin.y;
|
|
return (int)(adjY / m_virtualScreenWindowBounds.height * m_screenHeight);
|
|
}
|
|
|
|
void Graphics::toggleFullScreen() {
|
|
if (IsWindowFullscreen()) {
|
|
ToggleFullscreen();
|
|
SetWindowSize(m_startupScreenWidth, m_startupScreenHeight);
|
|
m_windowWidth = m_startupScreenWidth;
|
|
m_windowHeight = m_startupScreenHeight;
|
|
} else {
|
|
int monitor = GetCurrentMonitor();
|
|
m_windowWidth = GetMonitorWidth(monitor);
|
|
m_windowHeight = GetMonitorHeight(monitor);
|
|
SetWindowSize(m_windowWidth, m_windowHeight);
|
|
ToggleFullscreen();
|
|
|
|
}
|
|
calculateScreenPositionInWindow();
|
|
}
|
|
|
|
void Graphics::bindMethods(pkpy::VM *vm) {
|
|
vm->bind(vm->builtins, "clear(color: int)", [this](pkpy::VM* vm, pkpy::ArgsView args){
|
|
int index = pkpy::py_cast<int>(vm, args[0]);
|
|
Clear(index);
|
|
return vm->None;
|
|
});
|
|
|
|
vm->bind(vm->builtins, "pixel(x: int, y: int, color: int)", [this](pkpy::VM* vm, pkpy::ArgsView args){
|
|
float x = pkpy::py_cast<float>(vm, args[0]);
|
|
float y = pkpy::py_cast<float>(vm, args[1]);
|
|
float paletteIndex = pkpy::py_cast<float>(vm, args[2]);
|
|
this->Pixel(x, y, paletteIndex);
|
|
return vm->None;
|
|
});
|
|
|
|
vm->bind(vm->builtins, "get_pixel(x: int, y: int) -> int", [this](pkpy::VM* vm, pkpy::ArgsView args){
|
|
float x = pkpy::py_cast<float>(vm, args[0]);
|
|
float y = pkpy::py_cast<float>(vm, args[1]);
|
|
|
|
return pkpy::py_var(vm, this->GetPixel(x, y));
|
|
});
|
|
|
|
vm->bind(vm->builtins, "circle(x: int, y: int, radius: float, color: int)", [this](pkpy::VM* vm, pkpy::ArgsView args){
|
|
float x = pkpy::py_cast<float>(vm, args[0]);
|
|
float y = pkpy::py_cast<float>(vm, args[1]);
|
|
float radius = pkpy::py_cast<float>(vm, args[2]);
|
|
float paletteIndex = pkpy::py_cast<float>(vm, args[3]);
|
|
this->Circle(x, y, radius, paletteIndex);
|
|
return vm->None;
|
|
});
|
|
|
|
vm->bind(vm->builtins, "rectangle(x: int, y: int, width: int, height: int, color: int)", [this](pkpy::VM* vm, pkpy::ArgsView args){
|
|
float x = pkpy::py_cast<float>(vm, args[0]);
|
|
float y = pkpy::py_cast<float>(vm, args[1]);
|
|
float width = pkpy::py_cast<float>(vm, args[2]);
|
|
float height = pkpy::py_cast<float>(vm, args[3]);
|
|
float paletteIndex = pkpy::py_cast<float>(vm, args[4]);
|
|
this->Rect(x, y, width, height, paletteIndex);
|
|
return vm->None;
|
|
});
|
|
|
|
vm->bind(vm->builtins, "triangle(x1: int, y1: int, x2: int, y2: int, x3: int, y3: int, color: int)", [this](pkpy::VM* vm, pkpy::ArgsView args){
|
|
float x1 = pkpy::py_cast<float>(vm, args[0]);
|
|
float y1 = pkpy::py_cast<float>(vm, args[1]);
|
|
float x2 = pkpy::py_cast<float>(vm, args[2]);
|
|
float y2 = pkpy::py_cast<float>(vm, args[3]);
|
|
float x3 = pkpy::py_cast<float>(vm, args[4]);
|
|
float y3 = pkpy::py_cast<float>(vm, args[5]);
|
|
float paletteIndex = pkpy::py_cast<float>(vm, args[6]);
|
|
this->Triangle(x1, y1, x2, y2, x3, y3, paletteIndex);
|
|
return vm->None;
|
|
});
|
|
|
|
vm->bind(vm->builtins, "text(t: string, x: int, y: int, color: int)", [this](pkpy::VM* vm, pkpy::ArgsView args){
|
|
pkpy::PyObject* func_str = vm->builtins->attr("str");
|
|
pkpy::PyObject* result = vm->call(func_str, args[0]);
|
|
std::string s = pkpy::py_cast<pkpy::Str&>(vm, result).str();
|
|
|
|
float x = pkpy::py_cast<float>(vm, args[1]);
|
|
float y = pkpy::py_cast<float>(vm, args[2]);
|
|
float paletteIndex = pkpy::py_cast<float>(vm, args[3]);
|
|
this->Text(s, x, y, paletteIndex);
|
|
return vm->None;
|
|
});
|
|
}
|
|
|
|
void Graphics::Clear(int paletteIndex) {
|
|
for (int y = 0; y < m_screenHeight; ++y) {
|
|
for (int x = 0; x < m_screenWidth; ++x) {
|
|
Pixel(x, y, paletteIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Graphics::Pixel(int x, int y, int paletteIndex) {
|
|
paletteIndex = Clamp(paletteIndex, 0, m_paletteByID.size() - 1);
|
|
if(x < 0 || y < 0 || x >= m_screenWidth || y >= m_screenHeight) return;
|
|
|
|
m_virtualScreenColorBuffer[y * m_screenWidth + x] = paletteIndex;
|
|
}
|
|
|
|
void Graphics::Circle(int x, int y, int radius, int paletteIndex) {
|
|
Ellipse(x, y, radius, radius, paletteIndex);
|
|
}
|
|
|
|
void Graphics::Ellipse(int x, int y, int w, int h, int paletteIndex){
|
|
|
|
int x0 = x - w;
|
|
int y0 = y - h;
|
|
int x1 = x + w;
|
|
int y1 = y + h;
|
|
|
|
if(x0 > x1 || y0 > y1)
|
|
return;
|
|
|
|
int a = abs(x1 - x0), b = abs(y1 - y0), b1 = b & 1;
|
|
int dx = 4 * (1 - a) * b * b, dy = 4 * (b1 + 1) * a * a;
|
|
int err = dx + dy + b1 * a * a, e2;
|
|
|
|
if (x0 > x1) { x0 = x1; x1 += a; }
|
|
if (y0 > y1) y0 = y1;
|
|
y0 += (b + 1) / 2; y1 = y0 - b1;
|
|
a *= 8 * a; b1 = 8 * b * b;
|
|
|
|
int prevY = y0;
|
|
do
|
|
{
|
|
Pixel( x1, y0, paletteIndex);
|
|
Pixel( x0, y0, paletteIndex);
|
|
Pixel( x0, y1, paletteIndex);
|
|
Pixel( x1, y1, paletteIndex);
|
|
if(y0 != prevY && (y0 - y) != h){
|
|
h_line(x1, y0, x - (x1 - x) + 1, paletteIndex);
|
|
h_line(x1, y - (y0 - y), x - (x1 - x) + 1, paletteIndex);
|
|
}
|
|
prevY = y0;
|
|
e2 = 2 * err;
|
|
if (e2 <= dy) { y0++; y1--; err += dy += a; } /* y step */
|
|
if (e2 >= dx || 2 * err > dy) { x0++; x1--; err += dx += b1; } /* x step */
|
|
} while (x0 <= x1);
|
|
|
|
while (y0-y1 < b)
|
|
{ /* too early stop of flat ellipses a=1 */
|
|
Pixel( x0 - 1, y0, paletteIndex); /* -> finish tip of ellipse */
|
|
Pixel( x1 + 1, y0++, paletteIndex);
|
|
Pixel( x0 - 1, y1, paletteIndex);
|
|
Pixel( x1 + 1, y1--, paletteIndex);
|
|
}
|
|
|
|
|
|
h_line(x - w, y, x + w, paletteIndex);
|
|
}
|
|
|
|
void Graphics::EllipseBorder(int x, int y, int w, int h, int paletteIndex){
|
|
|
|
int x0 = x - w;
|
|
int y0 = y - h;
|
|
int x1 = x + w;
|
|
int y1 = y + h;
|
|
|
|
if(x0 > x1 || y0 > y1)
|
|
return;
|
|
|
|
int a = abs(x1 - x0), b = abs(y1 - y0), b1 = b & 1;
|
|
int dx = 4 * (1 - a) * b * b, dy = 4 * (b1 + 1) * a * a;
|
|
int err = dx + dy + b1 * a * a, e2;
|
|
|
|
if (x0 > x1) { x0 = x1; x1 += a; }
|
|
if (y0 > y1) y0 = y1;
|
|
y0 += (b + 1) / 2; y1 = y0 - b1;
|
|
a *= 8 * a; b1 = 8 * b * b;
|
|
|
|
do
|
|
{
|
|
Pixel( x1, y0, paletteIndex);
|
|
Pixel( x0, y0, paletteIndex);
|
|
Pixel( x0, y1, paletteIndex);
|
|
Pixel( x1, y1, paletteIndex);
|
|
|
|
e2 = 2 * err;
|
|
if (e2 <= dy) { y0++; y1--; err += dy += a; } /* y step */
|
|
if (e2 >= dx || 2 * err > dy) { x0++; x1--; err += dx += b1; } /* x step */
|
|
} while (x0 <= x1);
|
|
|
|
while (y0-y1 < b)
|
|
{ /* too early stop of flat ellipses a=1 */
|
|
Pixel( x0 - 1, y0, paletteIndex); /* -> finish tip of ellipse */
|
|
Pixel( x1 + 1, y0++, paletteIndex);
|
|
Pixel( x0 - 1, y1, paletteIndex);
|
|
Pixel( x1 + 1, y1--, paletteIndex);
|
|
}
|
|
|
|
}
|
|
|
|
void Graphics::Rect(int x, int y, int width, int height, int paletteIndex) {
|
|
for (int i = 0; i < height; ++i) {
|
|
h_line(x, y + i, x + width - 1, paletteIndex);
|
|
}
|
|
}
|
|
|
|
void Graphics::RectBorder(int x, int y, int width, int height, int paletteIndex) {
|
|
h_line(x, y, x + width - 1, paletteIndex);
|
|
h_line(x, y + height - 1, x + width - 1, paletteIndex);
|
|
v_line(x, y + 1, y + height - 2, paletteIndex);
|
|
v_line(x + width - 1, y + 1, y + height - 2, paletteIndex);
|
|
}
|
|
|
|
void Graphics::Text(const std::string& s, int x, int y, int paletteIndex) {
|
|
|
|
for (int i = 0; i < s.size(); ++i) {
|
|
char c = s[i];
|
|
std::string bitData = m_currentFont->GetCharData((int)c);
|
|
|
|
//std::cout << c << ": " << (int)c << " = " << bitData << std::endl;
|
|
for (int j = 0; j < bitData.size(); ++j) {
|
|
if(bitData[j] == '1')
|
|
Pixel(x + (j % m_currentFont->GetWidth()) + ((m_currentFont->GetWidth() + 1) * i), y + (j / m_currentFont->GetWidth()), paletteIndex);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
void Graphics::updateVMVars(pkpy::VM* vm) {
|
|
vm->builtins->attr().set("mouseX", pkpy::py_var(vm, mouseX()));
|
|
vm->builtins->attr().set("mouseY", pkpy::py_var(vm, mouseY()));
|
|
vm->builtins->attr().set("width", pkpy::py_var(vm, m_screenWidth));
|
|
vm->builtins->attr().set("height", pkpy::py_var(vm, m_screenHeight));
|
|
}
|
|
|
|
void Graphics::h_line(int x1, int y, int x2, int paletteIndex) {
|
|
if(y < 0 || y >= m_screenHeight) return;
|
|
int startX = x1;
|
|
int endX = x2;
|
|
if(x1 > x2){
|
|
startX = x2;
|
|
endX = x1;
|
|
}
|
|
for (int i = startX; i <= endX; ++i) {
|
|
Pixel(i, y, paletteIndex);
|
|
}
|
|
}
|
|
|
|
void Graphics::v_line(int x, int y1, int y2, int paletteIndex) {
|
|
if(x < 0 || x >= m_screenWidth) return;
|
|
int startY = y1;
|
|
int endY = y2;
|
|
if(y1 > y2){
|
|
startY = y2;
|
|
endY = y1;
|
|
}
|
|
for (int i = startY; i <= endY; ++i) {
|
|
Pixel(x, i, paletteIndex);
|
|
}
|
|
}
|
|
|
|
int Graphics::GetPixel(int x, int y) {
|
|
if(x < 0 || y < 0 || x >= m_screenWidth || y >= m_screenHeight) return 0;
|
|
|
|
return m_virtualScreenColorBuffer[y * m_screenWidth + x];
|
|
}
|
|
|
|
// https://github.com/OneLoneCoder/olcPixelGameEngine/blob/master/olcPixelGameEngine.h#L2456
|
|
void Graphics::Triangle(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t x3, int32_t y3, int paletteIndex)
|
|
{
|
|
auto drawline = [&](int sx, int ex, int ny) { for (int i = sx; i <= ex; i++) Pixel(i, ny, paletteIndex); };
|
|
|
|
int t1x, t2x, y, minx, maxx, t1xp, t2xp;
|
|
bool changed1 = false;
|
|
bool changed2 = false;
|
|
int signx1, signx2, dx1, dy1, dx2, dy2;
|
|
int e1, e2;
|
|
// Sort vertices
|
|
if (y1 > y2) { std::swap(y1, y2); std::swap(x1, x2); }
|
|
if (y1 > y3) { std::swap(y1, y3); std::swap(x1, x3); }
|
|
if (y2 > y3) { std::swap(y2, y3); std::swap(x2, x3); }
|
|
|
|
t1x = t2x = x1; y = y1; // Starting points
|
|
dx1 = (int)(x2 - x1);
|
|
if (dx1 < 0) { dx1 = -dx1; signx1 = -1; }
|
|
else signx1 = 1;
|
|
dy1 = (int)(y2 - y1);
|
|
|
|
dx2 = (int)(x3 - x1);
|
|
if (dx2 < 0) { dx2 = -dx2; signx2 = -1; }
|
|
else signx2 = 1;
|
|
dy2 = (int)(y3 - y1);
|
|
|
|
if (dy1 > dx1) { std::swap(dx1, dy1); changed1 = true; }
|
|
if (dy2 > dx2) { std::swap(dy2, dx2); changed2 = true; }
|
|
|
|
e2 = (int)(dx2 >> 1);
|
|
// Flat top, just process the second half
|
|
if (y1 == y2) goto next;
|
|
e1 = (int)(dx1 >> 1);
|
|
|
|
for (int i = 0; i < dx1;) {
|
|
t1xp = 0; t2xp = 0;
|
|
if (t1x < t2x) { minx = t1x; maxx = t2x; }
|
|
else { minx = t2x; maxx = t1x; }
|
|
// process first line until y value is about to change
|
|
while (i < dx1) {
|
|
i++;
|
|
e1 += dy1;
|
|
while (e1 >= dx1) {
|
|
e1 -= dx1;
|
|
if (changed1) t1xp = signx1;//t1x += signx1;
|
|
else goto next1;
|
|
}
|
|
if (changed1) break;
|
|
else t1x += signx1;
|
|
}
|
|
// Move line
|
|
next1:
|
|
// process second line until y value is about to change
|
|
while (1) {
|
|
e2 += dy2;
|
|
while (e2 >= dx2) {
|
|
e2 -= dx2;
|
|
if (changed2) t2xp = signx2;//t2x += signx2;
|
|
else goto next2;
|
|
}
|
|
if (changed2) break;
|
|
else t2x += signx2;
|
|
}
|
|
next2:
|
|
if (minx > t1x) minx = t1x;
|
|
if (minx > t2x) minx = t2x;
|
|
if (maxx < t1x) maxx = t1x;
|
|
if (maxx < t2x) maxx = t2x;
|
|
drawline(minx, maxx, y); // Draw line from min to max points found on the y
|
|
// Now increase y
|
|
if (!changed1) t1x += signx1;
|
|
t1x += t1xp;
|
|
if (!changed2) t2x += signx2;
|
|
t2x += t2xp;
|
|
y += 1;
|
|
if (y == y2) break;
|
|
}
|
|
next:
|
|
// Second half
|
|
dx1 = (int)(x3 - x2); if (dx1 < 0) { dx1 = -dx1; signx1 = -1; }
|
|
else signx1 = 1;
|
|
dy1 = (int)(y3 - y2);
|
|
t1x = x2;
|
|
|
|
if (dy1 > dx1) { // swap values
|
|
std::swap(dy1, dx1);
|
|
changed1 = true;
|
|
}
|
|
else changed1 = false;
|
|
|
|
e1 = (int)(dx1 >> 1);
|
|
|
|
for (int i = 0; i <= dx1; i++) {
|
|
t1xp = 0; t2xp = 0;
|
|
if (t1x < t2x) { minx = t1x; maxx = t2x; }
|
|
else { minx = t2x; maxx = t1x; }
|
|
// process first line until y value is about to change
|
|
while (i < dx1) {
|
|
e1 += dy1;
|
|
while (e1 >= dx1) {
|
|
e1 -= dx1;
|
|
if (changed1) { t1xp = signx1; break; }//t1x += signx1;
|
|
else goto next3;
|
|
}
|
|
if (changed1) break;
|
|
else t1x += signx1;
|
|
if (i < dx1) i++;
|
|
}
|
|
next3:
|
|
// process second line until y value is about to change
|
|
while (t2x != x3) {
|
|
e2 += dy2;
|
|
while (e2 >= dx2) {
|
|
e2 -= dx2;
|
|
if (changed2) t2xp = signx2;
|
|
else goto next4;
|
|
}
|
|
if (changed2) break;
|
|
else t2x += signx2;
|
|
}
|
|
next4:
|
|
|
|
if (minx > t1x) minx = t1x;
|
|
if (minx > t2x) minx = t2x;
|
|
if (maxx < t1x) maxx = t1x;
|
|
if (maxx < t2x) maxx = t2x;
|
|
drawline(minx, maxx, y);
|
|
if (!changed1) t1x += signx1;
|
|
t1x += t1xp;
|
|
if (!changed2) t2x += signx2;
|
|
t2x += t2xp;
|
|
y += 1;
|
|
if (y > y3) return;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
PycronImage* Graphics::loadImage(std::string path) {
|
|
Image img = LoadImage(path.c_str());
|
|
ImageRotateCW(&img);
|
|
ImageFlipHorizontal(&img);
|
|
if(img.width == 0 && img.height == 0) std::cerr << "Image at path " << path << " is empty\n";
|
|
Color* colors = LoadImageColors(img);
|
|
auto* idImg = new PycronImage(img.width, img.height);
|
|
for (int i = 0; i < idImg->data.size(); ++i) {
|
|
if(colors[i].a == 0){
|
|
idImg->data[i] = -1;
|
|
}else{
|
|
idImg->data[i] = (int8_t)rgbToID(colors[i].r, colors[i].g, colors[i].b);
|
|
}
|
|
}
|
|
return idImg;
|
|
}
|
|
|
|
void Graphics::Img(PycronImage* img, int x, int y) {
|
|
for (int i = 0; i < img->data.size(); ++i) {
|
|
if(img->data[i] == -1) continue;
|
|
Pixel(x + i / img->width, y + i % img->width, img->data[i]);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|