nikola/treender
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

use mrand in baground

Browse Source
This commit is contained in:
nikola 2024-12-02 01:11:33 +01:00
parent d77cca5527
commit 7d9b16cac8
4 changed files with 26 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
inc/canvas/BackGround.hpp
View File

@ -1,11 +1,9 @@
#include <vector> #include <vector>
#include "values/RandBuffer.hpp"
#include "canvas/Sun.hpp" #include "canvas/Sun.hpp"
#include <raylib.h> #include <raylib.h>
struct Moon struct Moon
{ {
float x; float x;
@ -31,8 +29,6 @@ private:
Sun sun; Sun sun;
RandBuffer starBuff;
RandBuffer mountenBuff;
Moon m_moon; Moon m_moon;
int colorSet; int colorSet;
int time; int time;

2
src/App.cpp
View File

@ -14,7 +14,7 @@ void App::init(int screenWidth, int screenHeight)
this->screenHeight = screenHeight; this->screenHeight = screenHeight;
this->canvas.init(screenWidth); this->canvas.init(screenWidth);
mrand::setSeed((unsigned int)time(NULL)); mrand::setSeed(1);
for (size_t i = 0; i < canvasTexure.size(); i++) for (size_t i = 0; i < canvasTexure.size(); i++)
{ {

15
src/canvas/BackGround.cpp
View File

@ -23,8 +23,7 @@ void BackGround::deinit()
void BackGround::newGen() void BackGround::newGen()
{ {
starBuff.reset();
mountenBuff.reset();
m_moon = {mrand::getFloat(), mrand::getFloat(), mrand::getFloat()}; m_moon = {mrand::getFloat(), mrand::getFloat(), mrand::getFloat()};
colorSet = mrand::getValue(0, 3); colorSet = mrand::getValue(0, 3);
time = floor(Remap(m_moon.y, 0, 1, 4, 0)); time = floor(Remap(m_moon.y, 0, 1, 4, 0));
@ -61,10 +60,10 @@ void BackGround::drawStarts()
for (size_t i = 0; i < numOfStarts; i++) for (size_t i = 0; i < numOfStarts; i++)
{ {
int x = starBuff.next() * size; int x = mrand::getFloat() * size;
int y = starBuff.next() * size; int y = mrand::getFloat() * size;
int weight = starBuff.next() * 3 + 1; int weight = mrand::getFloat() * 3 + 1;
float alph = Normalize(starBuff.next(), 0.04f, 0.8f); float alph = Normalize(mrand::getFloat(), 0.04f, 0.8f);
Color color = ColorLerp(BackGroundColors::backGroundColor, BackGroundColors::starColor, alph); Color color = ColorLerp(BackGroundColors::backGroundColor, BackGroundColors::starColor, alph);
rlColor4ub(color.r, color.g, color.b, color.a); rlColor4ub(color.r, color.g, color.b, color.a);
@ -121,7 +120,7 @@ void BackGround::drawMounten(size_t mountenSegments, int min, int max, Color col
int x = 0; int x = 0;
int diff = size / (mountenSegments - 1); int diff = size / (mountenSegments - 1);
float p = mountenBuff.next(); float p = mrand::getFloat();
int y = Lerp(min, max, p); int y = Lerp(min, max, p);
rlSetTexture(1); rlSetTexture(1);
@ -136,7 +135,7 @@ void BackGround::drawMounten(size_t mountenSegments, int min, int max, Color col
// bottomLeft // bottomLeft
rlVertex2f(x, size); rlVertex2f(x, size);
p = mountenBuff.next(); p = mrand::getFloat();
y = Lerp(min, max, p); y = Lerp(min, max, p);
x += diff; x += diff;
// topRight // topRight

25
src/values/mrand.cpp
View File

@ -3,7 +3,6 @@
#include "values/mrand.hpp" #include "values/mrand.hpp"
static uint32_t rprand_state[4] = {0}; static uint32_t rprand_state[4] = {0};
static uint64_t rprand_seed = 0;
static inline uint32_t my_rotate_left(const uint32_t x, int k) static inline uint32_t my_rotate_left(const uint32_t x, int k)
{ {
@ -27,7 +26,7 @@ uint32_t my_rprand_xoshiro(uint32_t state[4])
return result; return result;
} }
uint64_t rprand_splitmix64() uint64_t rprand_splitmix64(uint64_t &rprand_seed)
{ {
uint64_t z = (rprand_seed += 0x9e3779b97f4a7c15); uint64_t z = (rprand_seed += 0x9e3779b97f4a7c15);
z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9; z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
@ -39,14 +38,14 @@ namespace mrand
{ {
void setSeed(unsigned long long seed) void setSeed(unsigned long long seed)
{ {
rprand_seed = (uint64_t)seed; // Set SplitMix64 seed for further use uint64_t rprand_seed = (uint64_t)seed; // Set SplitMix64 seed for further use
// To generate the Xoshiro128** state, we use SplitMix64 generator first // To generate the Xoshiro128** state, we use SplitMix64 generator first
// We generate 4 pseudo-random 64bit numbers that we combine using their LSB|MSB // We generate 4 pseudo-random 64bit numbers that we combine using their LSB|MSB
rprand_state[0] = (uint32_t)(rprand_splitmix64() & 0xffffffff); rprand_state[0] = (uint32_t)(rprand_splitmix64(rprand_seed) & 0xffffffff);
rprand_state[1] = (uint32_t)((rprand_splitmix64() & 0xffffffff00000000) >> 32); rprand_state[1] = (uint32_t)((rprand_splitmix64(rprand_seed) & 0xffffffff00000000) >> 32);
rprand_state[2] = (uint32_t)(rprand_splitmix64() & 0xffffffff); rprand_state[2] = (uint32_t)(rprand_splitmix64(rprand_seed) & 0xffffffff);
rprand_state[3] = (uint32_t)((rprand_splitmix64() & 0xffffffff00000000) >> 32); rprand_state[3] = (uint32_t)((rprand_splitmix64(rprand_seed) & 0xffffffff00000000) >> 32);
} }
int getValue(int min, int max) int getValue(int min, int max)
@ -60,4 +59,16 @@ namespace mrand
{ {
return my_rprand_xoshiro(rprand_state) / 4294967295.0f; return my_rprand_xoshiro(rprand_state) / 4294967295.0f;
} }
int getValue(int min, int max, uint32_t state[4])
{
int value = my_rprand_xoshiro(state) % (std::abs(max - min) + 1) + min;
return value;
}
float getFloat(uint32_t state[4])
{
return my_rprand_xoshiro(state) / 4294967295.0f;
}
} }