You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
273 lines
8.1 KiB
273 lines
8.1 KiB
/*******************************************************************************************
|
|
*
|
|
* raylib [shapes] example - penrose tile
|
|
*
|
|
* Example complexity rating: [★★★★] 4/4
|
|
*
|
|
* Example originally created with raylib 5.5
|
|
* Based on: https://processing.org/examples/penrosetile.html
|
|
*
|
|
* Example contributed by David Buzatto (@davidbuzatto) and reviewed by Ramon Santamaria (@raysan5)
|
|
*
|
|
* Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
|
|
* BSD-like license that allows static linking with closed source software
|
|
*
|
|
* Copyright (c) 2025 David Buzatto (@davidbuzatto)
|
|
*
|
|
********************************************************************************************/
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include "raylib.h"
|
|
|
|
#define STR_MAX_SIZE 10000
|
|
#define TURTLE_STACK_MAX_SIZE 50
|
|
|
|
typedef struct TurtleState {
|
|
Vector2 origin;
|
|
double angle;
|
|
} TurtleState;
|
|
|
|
typedef struct PenroseLSystem {
|
|
int steps;
|
|
char *production;
|
|
const char *ruleW;
|
|
const char *ruleX;
|
|
const char *ruleY;
|
|
const char *ruleZ;
|
|
float drawLength;
|
|
float theta;
|
|
} PenroseLSystem;
|
|
|
|
static TurtleState turtleStack[TURTLE_STACK_MAX_SIZE];
|
|
static int turtleTop = -1;
|
|
|
|
void PushTurtleState(TurtleState state)
|
|
{
|
|
if (turtleTop < TURTLE_STACK_MAX_SIZE - 1)
|
|
{
|
|
turtleStack[++turtleTop] = state;
|
|
}
|
|
else
|
|
{
|
|
TraceLog(LOG_WARNING, "TURTLE STACK OVERFLOW!");
|
|
}
|
|
}
|
|
|
|
TurtleState PopTurtleState(void)
|
|
{
|
|
if (turtleTop >= 0)
|
|
{
|
|
return turtleStack[turtleTop--];
|
|
}
|
|
else
|
|
{
|
|
TraceLog(LOG_WARNING, "TURTLE STACK UNDERFLOW!");
|
|
}
|
|
return (TurtleState) {0};
|
|
}
|
|
|
|
PenroseLSystem CreatePenroseLSystem(float drawLength)
|
|
{
|
|
PenroseLSystem ls = {
|
|
.steps = 0,
|
|
.ruleW = "YF++ZF4-XF[-YF4-WF]++",
|
|
.ruleX = "+YF--ZF[3-WF--XF]+",
|
|
.ruleY = "-WF++XF[+++YF++ZF]-",
|
|
.ruleZ = "--YF++++WF[+ZF++++XF]--XF",
|
|
.drawLength = drawLength,
|
|
.theta = 36.0f // in degrees
|
|
};
|
|
ls.production = (char*) malloc(sizeof(char) * STR_MAX_SIZE);
|
|
ls.production[0] = '\0';
|
|
strncpy(ls.production, "[X]++[X]++[X]++[X]++[X]", STR_MAX_SIZE);
|
|
return ls;
|
|
}
|
|
|
|
void DrawPenroseLSystem(PenroseLSystem *ls)
|
|
{
|
|
Vector2 screenCenter = {GetScreenWidth()/2, GetScreenHeight()/2};
|
|
|
|
TurtleState turtle = {
|
|
.origin = {0},
|
|
.angle = -90.0f
|
|
};
|
|
|
|
int repeats = 1;
|
|
int productionLength = (int) strnlen(ls->production, STR_MAX_SIZE);
|
|
ls->steps += 12;
|
|
|
|
if (ls->steps > productionLength)
|
|
{
|
|
ls->steps = productionLength;
|
|
}
|
|
|
|
for (int i = 0; i < ls->steps; i++)
|
|
{
|
|
char step = ls->production[i];
|
|
if ( step == 'F' )
|
|
{
|
|
for ( int j = 0; j < repeats; j++ )
|
|
{
|
|
Vector2 startPosWorld = turtle.origin;
|
|
float radAngle = DEG2RAD * turtle.angle;
|
|
turtle.origin.x += ls->drawLength * cosf(radAngle);
|
|
turtle.origin.y += ls->drawLength * sinf(radAngle);
|
|
Vector2 startPosScreen = {startPosWorld.x + screenCenter.x, startPosWorld.y + screenCenter.y};
|
|
Vector2 endPosScreen = {turtle.origin.x + screenCenter.x, turtle.origin.y + screenCenter.y};
|
|
DrawLineEx(startPosScreen, endPosScreen, 2, Fade(BLACK, 0.2));
|
|
}
|
|
repeats = 1;
|
|
}
|
|
else if ( step == '+' )
|
|
{
|
|
for ( int j = 0; j < repeats; j++ )
|
|
{
|
|
turtle.angle += ls->theta;
|
|
}
|
|
repeats = 1;
|
|
}
|
|
else if ( step == '-' )
|
|
{
|
|
for ( int j = 0; j < repeats; j++ )
|
|
{
|
|
turtle.angle += -ls->theta;
|
|
}
|
|
repeats = 1;
|
|
}
|
|
else if ( step == '[' )
|
|
{
|
|
PushTurtleState(turtle);
|
|
}
|
|
else if ( step == ']' )
|
|
{
|
|
turtle = PopTurtleState();
|
|
}
|
|
else if ( ( step >= 48 ) && ( step <= 57 ) )
|
|
{
|
|
repeats = (int) step - 48;
|
|
}
|
|
}
|
|
|
|
turtleTop = -1;
|
|
|
|
}
|
|
|
|
void BuildProductionStep(PenroseLSystem *ls)
|
|
{
|
|
char *newProduction = (char*) malloc(sizeof(char) * STR_MAX_SIZE);
|
|
newProduction[0] = '\0';
|
|
|
|
int productionLength = strnlen(ls->production, STR_MAX_SIZE);
|
|
|
|
for (int i = 0; i < productionLength; i++)
|
|
{
|
|
char step = ls->production[i];
|
|
int remainingSpace = STR_MAX_SIZE - strnlen(newProduction, STR_MAX_SIZE) - 1;
|
|
switch (step)
|
|
{
|
|
case 'W': strncat(newProduction, ls->ruleW, remainingSpace); break;
|
|
case 'X': strncat(newProduction, ls->ruleX, remainingSpace); break;
|
|
case 'Y': strncat(newProduction, ls->ruleY, remainingSpace); break;
|
|
case 'Z': strncat(newProduction, ls->ruleZ, remainingSpace); break;
|
|
default:
|
|
{
|
|
if (step != 'F')
|
|
{
|
|
int t = strnlen(newProduction, STR_MAX_SIZE);
|
|
newProduction[t] = step;
|
|
newProduction[t+1] = '\0';
|
|
}
|
|
} break;
|
|
}
|
|
}
|
|
|
|
ls->drawLength *= 0.5f;
|
|
strncpy(ls->production, newProduction, STR_MAX_SIZE);
|
|
free( newProduction );
|
|
}
|
|
|
|
void BuildPenroseLSystem(PenroseLSystem *ls, float drawLength, int generations)
|
|
{
|
|
*ls = CreatePenroseLSystem(drawLength);
|
|
for (int i = 0; i < generations; i++)
|
|
{
|
|
BuildProductionStep(ls);
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// Program main entry point
|
|
//------------------------------------------------------------------------------------
|
|
int main(void)
|
|
{
|
|
// Initialization
|
|
//--------------------------------------------------------------------------------------
|
|
const int screenWidth = 800;
|
|
const int screenHeight = 450;
|
|
|
|
SetConfigFlags( FLAG_MSAA_4X_HINT );
|
|
InitWindow(screenWidth, screenHeight, "raylib [shapes] example - penrose tile");
|
|
|
|
float drawLength = 460.0f;
|
|
int minGenerations = 0;
|
|
int maxGenerations = 4;
|
|
int generations = 0;
|
|
|
|
PenroseLSystem ls = {0};
|
|
BuildPenroseLSystem(&ls, drawLength * (generations / (float) maxGenerations), generations);
|
|
|
|
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
|
|
//---------------------------------------------------------------------------------------
|
|
|
|
// Main game loop
|
|
while (!WindowShouldClose()) // Detect window close button or ESC key
|
|
{
|
|
// Update
|
|
//----------------------------------------------------------------------------------
|
|
bool rebuild = false;
|
|
if (IsKeyPressed(KEY_UP))
|
|
{
|
|
if (generations < maxGenerations)
|
|
{
|
|
generations++;
|
|
rebuild = true;
|
|
}
|
|
}
|
|
else if (IsKeyPressed(KEY_DOWN))
|
|
{
|
|
if (generations > minGenerations)
|
|
{
|
|
generations--;
|
|
rebuild = generations > 0;
|
|
}
|
|
}
|
|
if (rebuild)
|
|
{
|
|
BuildPenroseLSystem(&ls, drawLength * (generations / (float) maxGenerations), generations);
|
|
}
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Draw
|
|
//----------------------------------------------------------------------------------
|
|
BeginDrawing();
|
|
ClearBackground( RAYWHITE );
|
|
if (generations > 0)
|
|
{
|
|
DrawPenroseLSystem(&ls);
|
|
}
|
|
DrawText("penrose l-system", 10, 10, 20, DARKGRAY);
|
|
DrawText("press up or down to change generations", 10, 30, 20, DARKGRAY);
|
|
DrawText(TextFormat("generations: %d", generations), 10, 50, 20, DARKGRAY);
|
|
EndDrawing();
|
|
//----------------------------------------------------------------------------------
|
|
}
|
|
|
|
// De-Initialization
|
|
//--------------------------------------------------------------------------------------
|
|
CloseWindow(); // Close window and OpenGL context
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
return 0;
|
|
}
|