Fix bReleased boolean flags so they only trigger on actual release..

Disable log messages.
Fix potential bug with sending too many updates too quickly. Add in input handling.
2025-02-20 20:29:03 -06:00 · 2024-11-30 18:19:07 -06:00 · 2024-11-28 05:11:31 -06:00 · 2024-11-26 22:51:23 -06:00
11 changed files with 6822 additions and 5754 deletions
--- a/sample/PGEX_SMX.h
+++ b/sample/PGEX_SMX.h
@ -1,6 +1,7 @@
 #pragma once
 #include "olcPixelGameEngine.h"
 #include "SMX.h"
+#include <assert.h>

 using namespace olc;

@ -15,15 +16,17 @@ public:
    //LEFT is 0x08
    //Add these bytes together to get the combination (all 4 held down is 0xAA
    HWButton GetPanel(Key k,int pad=0)const{
-        return panelState[k-UP];
+        return panelState[k-UP][pad];
    };
    void EnableLogMessages(bool enabled){
        logMessages=enabled;
    }
 private:
    static bool logMessages;
-    HWButton internal_panelState[4];
-    HWButton panelState[4]; //We store the 4 main panel states, similar to how PGE does.
+    HWButton internal_panelState[4][2];
+    HWButton panelState[4][2]; //We store the 4 main panel states, similar to how PGE does.
+    double totalElapsedTime{0.};
+    double nextLightUpdate{0.};
    //SMX "screen" is 12x21
    //Each panel is 4x7
    static void SMXStateChangedCallback(int pad, SMXUpdateCallbackReason reason, void *pUser)
@ -44,31 +47,57 @@ private:
    {
        if(logMessages){
            printf("Device %i state changed: %04x\n", pad, SMX_GetInputState(pad));
+            printf("Device %i state changed: %04x\n", 1, SMX_GetInputState(1));
        }
-        int16_t state(SMX_GetInputState(pad));
-        if(state&0x2&&!internal_panelState[UP-UP].bPressed){
-            internal_panelState[UP-UP]={true,false,true};
+        int16_t state(SMX_GetInputState(0));
+        if(state&0x2&&!internal_panelState[UP-UP][0].bPressed){
+            internal_panelState[UP-UP][0]={true,false,true};
        }else
-        if(!(state&0x2)&&!internal_panelState[UP-UP].bReleased){
-            internal_panelState[UP-UP]={false,true,false};
+        if(!(state&0x2)&&internal_panelState[UP-UP][0].bHeld){
+            internal_panelState[UP-UP][0]={false,true,false};
        }
-        if(state&0x20&&!internal_panelState[RIGHT-UP].bPressed){
-            internal_panelState[RIGHT-UP]={true,false,true};
+        if(state&0x20&&!internal_panelState[RIGHT-UP][0].bPressed){
+            internal_panelState[RIGHT-UP][0]={true,false,true};
        }else
-        if(!(state&0x20)&&!internal_panelState[RIGHT-UP].bReleased){
-            internal_panelState[RIGHT-UP]={false,true,false};
+        if(!(state&0x20)&&internal_panelState[RIGHT-UP][0].bHeld){
+            internal_panelState[RIGHT-UP][0]={false,true,false};
        }
-        if(state&0x80&&!internal_panelState[DOWN-UP].bPressed){
-            internal_panelState[DOWN-UP]={true,false,true};
+        if(state&0x80&&!internal_panelState[DOWN-UP][0].bPressed){
+            internal_panelState[DOWN-UP][0]={true,false,true};
        }else
-        if(!(state&0x80)&&!internal_panelState[DOWN-UP].bReleased){
-            internal_panelState[DOWN-UP]={false,true,false};
+        if(!(state&0x80)&&internal_panelState[DOWN-UP][0].bHeld){
+            internal_panelState[DOWN-UP][0]={false,true,false};
        }
-        if(state&0x8&&!internal_panelState[LEFT-UP].bPressed){
-            internal_panelState[LEFT-UP]={true,false,true};
+        if(state&0x8&&!internal_panelState[LEFT-UP][0].bPressed){
+            internal_panelState[LEFT-UP][0]={true,false,true};
        }else
-        if(!(state&0x8)&&!internal_panelState[LEFT-UP].bReleased){
-            internal_panelState[LEFT-UP]={false,true,false};
+        if(!(state&0x8)&&internal_panelState[LEFT-UP][0].bHeld){
+            internal_panelState[LEFT-UP][0]={false,true,false};
+        }
+        state=SMX_GetInputState(1);
+        if(state&0x2&&!internal_panelState[UP-UP][1].bPressed){
+            internal_panelState[UP-UP][1]={true,false,true};
+        }else
+        if(!(state&0x2)&&internal_panelState[UP-UP][1].bHeld){
+            internal_panelState[UP-UP][1]={false,true,false};
+        }
+        if(state&0x20&&!internal_panelState[RIGHT-UP][1].bPressed){
+            internal_panelState[RIGHT-UP][1]={true,false,true};
+        }else
+        if(!(state&0x20)&&internal_panelState[RIGHT-UP][1].bHeld){
+            internal_panelState[RIGHT-UP][1]={false,true,false};
+        }
+        if(state&0x80&&!internal_panelState[DOWN-UP][1].bPressed){
+            internal_panelState[DOWN-UP][1]={true,false,true};
+        }else
+        if(!(state&0x80)&&internal_panelState[DOWN-UP][1].bHeld){
+            internal_panelState[DOWN-UP][1]={false,true,false};
+        }
+        if(state&0x8&&!internal_panelState[LEFT-UP][1].bPressed){
+            internal_panelState[LEFT-UP][1]={true,false,true};
+        }else
+        if(!(state&0x8)&&internal_panelState[LEFT-UP][1].bHeld){
+            internal_panelState[LEFT-UP][1]={false,true,false};
        }
    }

@ -79,18 +108,29 @@ private:
    virtual bool OnBeforeUserUpdate(float& fElapsedTime){
        //We don't want the panel states changing in the middle of a frame, since the input polling is on a separate thread.
        //Copy over the internal button states to the current panel state.
-        for(int i=0;i<4;i++){
-            panelState[i]=internal_panelState[i];
-            internal_panelState[i].bPressed=false;
-            internal_panelState[i].bReleased=false;
+        for(int pad=0;pad<2;pad++){
+            for(int i=0;i<4;i++){
+                panelState[i][pad]=internal_panelState[i][pad];
+                internal_panelState[i][pad].bPressed=false;
+                internal_panelState[i][pad].bReleased=false;
+            }
        }
        return false;
    }

    virtual void OnAfterUserUpdate(float fElapsedTime)override{
-        for(int i=0;i<4;i++){
-            panelState[i].bPressed=false;
-            panelState[i].bReleased=false;
+        double previousTotalElapsedTime{totalElapsedTime};
+        totalElapsedTime=fmod(totalElapsedTime+fElapsedTime,10000.);
+        if(previousTotalElapsedTime>totalElapsedTime){
+            //We are in the past, so reset lastLightUpdate to keep lights running.
+            nextLightUpdate=totalElapsedTime;
+        }
+        if(nextLightUpdate>totalElapsedTime)return; //Ignore light updates if not enough time has passed. We can only send light updates at 30 FPS.
+        for(int pad=0;pad<2;pad++){
+            for(int i=0;i<4;i++){
+                panelState[i][pad].bPressed=false;
+                panelState[i][pad].bReleased=false;
+            }
        }
        std::string lightData;
        //The light data for an SMX dance pad is outlined in the docs but the code used to transform the PGE's pixels to SMX pad's lights will be annotated here.
@ -105,7 +145,7 @@ private:
                            col++;
                            continue;
                        }
-                        Pixel p(pge->GetDrawTarget()->GetPixel(x,y));
+                        Pixel p(pge->GetDrawTarget()->GetPixel(x+12*pad,y));
                        lightData.append(1,p.r);
                        lightData.append(1,p.g);
                        lightData.append(1,p.b);
@ -121,7 +161,7 @@ private:
                            col++;
                            continue;
                        }
-                        Pixel p(pge->GetDrawTarget()->GetPixel(x,y));
+                        Pixel p(pge->GetDrawTarget()->GetPixel(x+12*pad,y));
                        lightData.append(1,p.r);
                        lightData.append(1,p.g);
                        lightData.append(1,p.b);
@ -131,6 +171,8 @@ private:
                }   
            }
        }
+        if(lightData.size()!=1350)throw;
+        nextLightUpdate=totalElapsedTime+1/30.f;
        SMX_SetLights2( lightData.data(), lightData.size() );
    }
 };
--- a/sample/PGEX_SMX_Example.cpp
+++ b/sample/PGEX_SMX_Example.cpp
@ -1,6 +1,7 @@
 #define OLC_PGE_APPLICATION
 #include "olcPixelGameEngine.h"
 #include "PGEX_SMX.h"
+#include "util.h"
 using namespace olc;

 class SMX_PGE : public olc::PixelGameEngine
@ -19,49 +20,187 @@ public:
    bool OnUserCreate() override
    {
        // Called once at the start, so create things here
+        //smx.EnableLogMessages(true);
        return true;
    }

+    struct Snow{
+        vf2d pos;
+        int id;
+    };
+
+    struct ExpandCircle{
+        vi2d pos;
+        float radius;
+        Pixel col;
+    };
+
+    std::vector<Snow>snow;
+    std::vector<Snow>backgroundSnow;
+    std::vector<ExpandCircle>expandCircles;
+    
+    const float backgroundSnowInterval{0.1f};
+    float backgroundSnowIntervalTimer{backgroundSnowInterval};
+    float backgroundSnowDirectionInterval{60.f};
+    
+    #define RIGHT true
+    bool backgroundSnowDirection{RIGHT};
+    float snowInterval{0.8f};
+    float snowTimer{snowInterval};
+    const float snowIntervalChangeInterval{60.f};
+    float snowIntervalTimer{snowIntervalChangeInterval};
+    double totalElapsedTime{0.};
+
+    float fallSpd{6.f};
+    float snowAmplitude{2.f};
+
+    std::map<std::pair<Key,int>,float>recreateCircleTimer{};
+    const float recreateCircleInterval{0.25f};
+
+    uint64_t SNOW_ID{0U};
+
    bool OnUserUpdate(float fElapsedTime) override
    {
-        smx.GetPanel(RIGHT, 0).bHeld;
-        if (GetKey(RIGHT).bPressed) {
-            mode = (mode + 1) % 3;
+        Clear({0,0,32});
+        backgroundSnowIntervalTimer-=fElapsedTime;
+        snowTimer-=fElapsedTime;
+        snowIntervalTimer-=fElapsedTime;
+        for(auto&[KEY,time]:recreateCircleTimer){
+            recreateCircleTimer[KEY]-=fElapsedTime;
        }
-        switch (mode) {
-            case 0: {
-                if (GetKey(SPACE).bPressed) {
-                    paused = !paused;
-                }
-                // called once per frame
-                if (!paused) {
-                    for (int x = 0; x < ScreenWidth(); x++)
-                        for (int y = 0; y < ScreenHeight(); y++)
-                            Draw(x, y, olc::Pixel(rand() % 255, rand() % 255, rand() % 255));
-                }
-            }break;
-            case 1: {
-                Clear(DARK_CYAN);
-                DrawRect({ 1,1 }, { 9,18 }, RED);
-            }break;
-            case 2: {
-                Clear(VERY_DARK_BLUE);
-                FillCircle(playerPos, 3,VERY_DARK_GREY);
-                DrawCircle(playerPos, 3);
-                if (GetKey(W).bHeld) {
-                    playerPos.y -= 5*fElapsedTime;
-                }
-                if (GetKey(A).bHeld) {
-                    playerPos.x -= 5 * fElapsedTime;
-                }
-                if (GetKey(S).bHeld) {
-                    playerPos.y += 5 * fElapsedTime;
-                }
-                if (GetKey(D).bHeld) {
-                    playerPos.x += 5 * fElapsedTime;
-                }
-            }break;
+        if(snowTimer<=0.f){
+            snow.emplace_back(vf2d{util::random(ScreenWidth()),-2.f},SNOW_ID++);
+            snowTimer=snowInterval;
        }
+        if(backgroundSnowIntervalTimer<=0.f){
+            int xOffset{int(util::random(ScreenWidth()))};
+            if(backgroundSnowDirection==RIGHT){
+                xOffset-=ScreenWidth()/2;
+            }else{
+                xOffset+=ScreenWidth()/2;
+            }
+            backgroundSnow.emplace_back(vf2d{float(xOffset),-2.f},SNOW_ID++);
+            backgroundSnowIntervalTimer=backgroundSnowInterval;
+        }
+        if(snowIntervalTimer<=0.f){
+            snowInterval=util::random_range(0.1f,2.f);
+            backgroundSnowDirection=!RIGHT;
+            if(rand()%2==0)backgroundSnowDirection=RIGHT;
+            snowIntervalTimer=snowIntervalChangeInterval;
+        }
+        for(Snow&backSnow:backgroundSnow){
+            srand(backSnow.id);
+            if(backgroundSnowDirection==RIGHT){
+                backSnow.pos.x+=fElapsedTime*snowAmplitude;
+            }else{
+                backSnow.pos.x-=fElapsedTime*snowAmplitude;
+            }
+            backSnow.pos.y+=fallSpd*fElapsedTime/2.f;
+            uint8_t randCol{uint8_t(10+rand()%50)};
+            Draw(backSnow.pos,Pixel{randCol,randCol,randCol});
+        }
+        for(Snow&snow:snow){
+            srand(snow.id);
+            float fallSpdMult{(rand()%25)/100.f};
+            snow.pos.y+=(fallSpd*(1.f-fallSpdMult))*fElapsedTime;
+            FillCircle(vi2d{int(snow.pos.x+sin(totalElapsedTime+snow.id*0.5f*fallSpd)*snowAmplitude),int(snow.pos.y)},rand()%2+1,{uint8_t(150+rand()%105),uint8_t(190+rand()%65),uint8_t(190+rand()%65)});
+        }
+        SetPixelMode(Pixel::ALPHA);
+        for(ExpandCircle&circle:expandCircles){
+            circle.radius+=fallSpd*fElapsedTime*6;
+            DrawCircle(circle.pos,circle.radius,circle.col);
+        }
+
+        std::erase_if(snow,[this](const Snow&snow){return snow.pos.y>ScreenHeight()+2;});
+        std::erase_if(backgroundSnow,[this](const Snow&backSnow){return backSnow.pos.y>ScreenHeight()+2;});
+        std::erase_if(expandCircles,[this](const ExpandCircle&circle){return circle.radius>24+2;});
+        double previousTotalElapsedTime{totalElapsedTime};
+        totalElapsedTime=fmod(totalElapsedTime+fElapsedTime,10000.);
+
+        #undef RIGHT
+        if(smx.GetPanel(RIGHT,0).bHeld){
+            FillRect({8,7},{3,6},{VERY_DARK_MAGENTA.r,VERY_DARK_MAGENTA.g,VERY_DARK_MAGENTA.b,64});
+            DrawRect({8,7},{3,6},VERY_DARK_MAGENTA);
+            if(recreateCircleTimer[{RIGHT,0}]<=0.f){
+                expandCircles.emplace_back(vi2d{8+1,7+3},1,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{8+1,7+3},0.5f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{8+1,7+3},0.f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                recreateCircleTimer[{RIGHT,0}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{RIGHT,0}]=0;
+        if(smx.GetPanel(UP,0).bHeld){
+            FillRect({4,0},{3,6},{VERY_DARK_MAGENTA.r,VERY_DARK_MAGENTA.g,VERY_DARK_MAGENTA.b,64});
+            DrawRect({4,0},{3,6},VERY_DARK_MAGENTA);
+            if(recreateCircleTimer[{UP,0}]<=0.f){
+                expandCircles.emplace_back(vi2d{4+1,0+3},1,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{4+1,0+3},0.5f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{4+1,0+3},0.f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                recreateCircleTimer[{UP,0}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{UP,0}]=0;
+        if(smx.GetPanel(DOWN,0).bHeld){
+            FillRect({4,14},{3,6},{VERY_DARK_MAGENTA.r,VERY_DARK_MAGENTA.g,VERY_DARK_MAGENTA.b,64});
+            DrawRect({4,14},{3,6},VERY_DARK_MAGENTA);
+            if(recreateCircleTimer[{DOWN,0}]<=0.f){
+                expandCircles.emplace_back(vi2d{4+1,14+3},1,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{4+1,14+3},0.5f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{4+1,14+3},0.f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                recreateCircleTimer[{DOWN,0}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{DOWN,0}]=0;
+        if(smx.GetPanel(LEFT,0).bHeld){
+            FillRect({0,7},{3,6},{VERY_DARK_MAGENTA.r,VERY_DARK_MAGENTA.g,VERY_DARK_MAGENTA.b,64});
+            DrawRect({0,7},{3,6},VERY_DARK_MAGENTA);
+            if(recreateCircleTimer[{LEFT,0}]<=0.f){
+                expandCircles.emplace_back(vi2d{0+1,7+3},1,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{0+1,7+3},0.5f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                expandCircles.emplace_back(vi2d{0+1,7+3},0.f,Pixel{DARK_MAGENTA.r,DARK_MAGENTA.g,DARK_MAGENTA.b,64});
+                recreateCircleTimer[{LEFT,0}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{LEFT,0}]=0;
+        if(smx.GetPanel(RIGHT,1).bHeld){
+            FillRect({20,7},{3,6},{VERY_DARK_CYAN.r,VERY_DARK_CYAN.g,VERY_DARK_CYAN.b,64});
+            DrawRect({20,7},{3,6},VERY_DARK_CYAN);
+            if(recreateCircleTimer[{RIGHT,1}]<=0.f){
+                expandCircles.emplace_back(vi2d{20+1,7+3},1,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{20+1,7+3},0.5f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{20+1,7+3},0.f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                recreateCircleTimer[{RIGHT,1}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{RIGHT,1}]=0;
+        if(smx.GetPanel(UP,1).bHeld){
+            FillRect({16,0},{3,6},{VERY_DARK_CYAN.r,VERY_DARK_CYAN.g,VERY_DARK_CYAN.b,64});
+            DrawRect({16,0},{3,6},VERY_DARK_CYAN);
+            if(recreateCircleTimer[{UP,1}]<=0.f){
+                expandCircles.emplace_back(vi2d{16+1,3+3},1,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{16+1,3+3},0.5f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{16+1,3+3},0.f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                recreateCircleTimer[{UP,1}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{UP,1}]=0;
+        if(smx.GetPanel(DOWN,1).bHeld){
+            FillRect({16,14},{3,6},{VERY_DARK_CYAN.r,VERY_DARK_CYAN.g,VERY_DARK_CYAN.b,64});
+            DrawRect({16,14},{3,6},VERY_DARK_CYAN);
+            if(recreateCircleTimer[{DOWN,1}]<=0.f){
+                expandCircles.emplace_back(vi2d{16+1,14+3},1,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{16+1,14+3},0.5f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{16+1,14+3},0.f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                recreateCircleTimer[{DOWN,1}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{DOWN,1}]=0;
+        if(smx.GetPanel(LEFT,1).bHeld){
+            FillRect({12,7},{3,6},{VERY_DARK_CYAN.r,VERY_DARK_CYAN.g,VERY_DARK_CYAN.b,64});
+            DrawRect({12,7},{3,6},VERY_DARK_CYAN);
+            if(recreateCircleTimer[{LEFT,1}]<=0.f){
+                expandCircles.emplace_back(vi2d{12+1,3+3},1,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{12+1,3+3},0.5f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                expandCircles.emplace_back(vi2d{12+1,3+3},0.f,Pixel{DARK_CYAN.r,DARK_CYAN.g,DARK_CYAN.b,64});
+                recreateCircleTimer[{LEFT,1}]=recreateCircleInterval;
+            }
+        }else recreateCircleTimer[{LEFT,1}]=0;
+
+        SetPixelMode(Pixel::MASK);
+
        return true;
    }
 };
@ -70,7 +209,7 @@ public:
 int main()
 {
    SMX_PGE demo;
-    if (demo.Construct(12, 21, 50, 50))
+    if (demo.Construct(24, 21, 50, 50,false,true))
        demo.Start();

    return 0;
--- a/sample/SMXSample.vcxproj
+++ b/sample/SMXSample.vcxproj
@ -62,7 +62,7 @@
      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <DisableSpecificWarnings>4063;4100;4127;4201;4244;4275;4355;4505;4512;4702;4786;4996;4996;4005;4018;4389;4389;4800;4592;%(DisableSpecificWarnings)</DisableSpecificWarnings>
      <AdditionalIncludeDirectories>..\sdk</AdditionalIncludeDirectories>
-      <LanguageStandard>stdcpp17</LanguageStandard>
+      <LanguageStandard>stdcpp20</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
@ -81,7 +81,7 @@
      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <DisableSpecificWarnings>4063;4100;4127;4201;4244;4275;4355;4505;4512;4702;4786;4996;4996;4005;4018;4389;4389;4800;4592;%(DisableSpecificWarnings)</DisableSpecificWarnings>
      <AdditionalIncludeDirectories>..\sdk</AdditionalIncludeDirectories>
-      <LanguageStandard>stdcpp17</LanguageStandard>
+      <LanguageStandard>stdcpp20</LanguageStandard>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
@ -93,6 +93,10 @@
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClCompile Include="PGEX_SMX_Example.cpp" />
+    <ClCompile Include="util.cpp">
+      <SubType>
+      </SubType>
+    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\sdk\Windows\SMX.vcxproj">
@ -102,6 +106,10 @@
  <ItemGroup>
    <ClInclude Include="olcPixelGameEngine.h" />
    <ClInclude Include="PGEX_SMX.h" />
+    <ClInclude Include="util.h">
+      <SubType>
+      </SubType>
+    </ClInclude>
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
--- a/sample/SMXSample.vcxproj.filters
+++ b/sample/SMXSample.vcxproj.filters
@ -13,6 +13,9 @@
    <ClCompile Include="PGEX_SMX_Example.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
+    <ClCompile Include="util.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="olcPixelGameEngine.h">
@ -21,5 +24,8 @@
    <ClInclude Include="PGEX_SMX.h">
      <Filter>Header Files</Filter>
    </ClInclude>
+    <ClInclude Include="util.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
  </ItemGroup>
 </Project>
--- a/sample/olcPixelGameEngine.h
+++ b/sample/olcPixelGameEngine.h
--- a/sample/util.cpp
+++ b/sample/util.cpp
@ -0,0 +1,152 @@
+#pragma region License
+/*
+License (OLC-3)
+~~~~~~~~~~~~~~~
+
+Copyright 2024 Joshua Sigona <sigonasr2@gmail.com>
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions or derivations of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions or derivative works in binary form must reproduce the above
+copyright notice. This list of conditions and the following	disclaimer must be
+reproduced in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may
+be used to endorse or promote products derived from this software without specific
+prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS	"AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+SHALL THE COPYRIGHT	HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL,	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+
+Portions of this software are copyright © 2024 The FreeType
+Project (www.freetype.org). Please see LICENSE_FT.txt for more information.
+All rights reserved.
+*/
+#pragma endregion
+#include "util.h"
+#include "olcPixelGameEngine.h"
+
+using namespace olc;
+
+std::random_device rd;
+std::mt19937 rng(rd());
+
+float util::random(float range){
+	static std::uniform_real_distribution<float>distrib(0,1);
+	return distrib(rng)*range;
+}
+
+int util::random(){
+	static std::uniform_int_distribution<int>distrib(0,32767);
+	return distrib(rng);
+}
+
+const float util::random_range(const float min,const float max){
+	return random(max-min)+min;
+}
+
+float util::radToDeg(float rad){
+	return rad*57.2957795130823208767f;
+}
+
+std::string util::timerStr(float time){
+	int seconds=int(time);
+	int hours=seconds/3600;
+	int minutes=seconds/60;
+
+	std::string timeStr="";
+	if(hours>0){
+		if(hours<10)timeStr+="0";
+		timeStr+=std::to_string(hours)+":";
+	}
+
+	if(minutes%60<10)timeStr+="0";
+	timeStr+=std::to_string(minutes%60)+":";
+
+	if(seconds%60<10)timeStr+="0";
+	timeStr+=std::to_string(seconds%60);
+
+	return timeStr;
+}
+
+std::string util::WrapText(PixelGameEngine*pge,std::string str,int width,bool proportional,vd2d scale){
+	std::string newStr="";
+	while(true){
+		std::string word="";
+		if(str.find(" ")==std::string::npos){
+			word=str;
+		}else{
+			word=str.substr(0,str.find(" "));
+		}
+		vi2d newSize = vd2d(proportional?pge->GetTextSizeProp(newStr+(newStr.size()>0?" ":"")+word):pge->GetTextSize(newStr+(newStr.size()>0?" ":"")+word))*scale;
+		if(newSize.x>width){
+			newStr+="\n"+word;
+		}else{
+			newStr+=(newStr.size()>0?" ":"")+word;
+		}
+		if(str.find(" ")==std::string::npos){
+			break;
+		}else{
+			str.erase(0,str.find(" ")+1);
+		}
+	}
+	return newStr;
+}
+
+
+#pragma region std::string util::GetHash(std::string fileName) //DO NOT MODIFY!
+std::string util::GetHash(std::string fileName){
+	//WARNING! This function is used to save/load files! This means if we ever modify this function all previous save files
+	//will no longer work! IN OTHER WORDS: DO NOT MODIFY THIS FUNCTION!
+	std::ifstream file(fileName);
+	std::string hash="";
+	uint8_t hashIndex=0;
+	while(file.good()){
+		uint8_t hashChar=0;
+		if(hash.size()==std::numeric_limits<uint8_t>::max()){
+			hashChar=hash[hashIndex];
+		}
+		char newChar=file.get();
+		if(newChar=='\r'||newChar=='\f'||newChar=='\n')continue;
+		hashChar+=newChar*21-7;
+		hashChar^=hashIndex;
+		if(hashIndex>0)hashChar+=hash[hashIndex-1];
+		hashChar%=94;
+		hashChar+=32;
+		if(hashChar=='"'||hashChar==',')hashChar+=60;
+		if(hashChar=='|')hashChar++; //FORBIDDEN CHARACTER IN EMSCRIPTEN BUILD!
+		if(hash.size()<std::numeric_limits<uint8_t>::max()){
+			hash+=hashChar;
+		}else{
+			hash[hashIndex]=hashChar;
+		}
+		hashIndex++;
+	}
+	file.close();
+	return hash;
+}
+#pragma endregion
+
+long double operator""_Pixels(long double unitDist){
+	return unitDist/100*24.;
+}
+
+const float util::distance(const vf2d&point1,const vf2d&point2){
+	return vf2d{point1-point2}.mag();
+}
+
+std::wstring util::to_wstring(const std::string&str){
+	return {str.begin(),str.end()};
+}
--- a/sample/util.h
+++ b/sample/util.h
@ -0,0 +1,114 @@
+#pragma region License
+/*
+License (OLC-3)
+~~~~~~~~~~~~~~~
+
+Copyright 2024 Joshua Sigona <sigonasr2@gmail.com>
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions or derivations of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions or derivative works in binary form must reproduce the above
+copyright notice. This list of conditions and the following	disclaimer must be
+reproduced in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may
+be used to endorse or promote products derived from this software without specific
+prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS	"AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+SHALL THE COPYRIGHT	HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL,	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+
+Portions of this software are copyright © 2024 The FreeType
+Project (www.freetype.org). Please see LICENSE_FT.txt for more information.
+All rights reserved.
+*/
+#pragma endregion
+#pragma once
+#include <stdlib.h>
+#include "olcPixelGameEngine.h"
+#include <random>
+
+namespace olc::util{
+	//Returns 0-range (as a float).
+	float random(float range);
+	//Returns a random float value min(inclusive) to max(exclusive).
+	const float random_range(const float min,const float max);
+	//Returns 0-32767 (as an int).
+	int random();
+	float radToDeg(float rad);
+
+	#pragma region Lerp templates + specializations
+	template<class T>
+	inline auto lerp(const T val1,const T val2,const float t){
+		return T(val1*(1-t)+val2*t);
+	}
+	
+	template<>
+	inline auto lerp<vf2d>(const vf2d val1,const vf2d val2,const float t){
+		return val1.lerp(val2,t);
+	}
+	
+	template<>
+	//NOTE: Also interpolates the alpha!!!
+	inline auto lerp<Pixel>(const Pixel val1,const Pixel val2,const float t){
+		Pixel col{PixelLerp(val1,val2,t)};
+		col.a=lerp(val1.a,val2.a,t);
+		return col;
+	}
+	#pragma endregion
+
+	template<class T,class U>
+	inline auto smoothstep(const T val1,const U val2,const float t){
+		auto x{decltype(val1+val2)(1-pow(1-t,3))};
+		return val1*(1-x)+val2*x;
+	}
+
+	std::string timerStr(float time);
+	std::string WrapText(PixelGameEngine*pge,std::string str,int width,bool proportional,vd2d scale);
+	std::string GetHash(std::string file);
+	const float distance(const vf2d&point1,const vf2d&point2);
+	std::wstring to_wstring(const std::string&str);
+	
+	template<class..._Args>
+	const std::string vformat(const std::string_view str,_Args..._Vals){
+		return std::vformat(str,std::make_format_args(_Vals...));
+	}
+	template<class..._Args>
+	const std::wstring wformat(const std::string_view str,_Args..._Vals){
+		return util::to_wstring(std::vformat(str,std::make_format_args(_Vals...)));
+	}
+
+	template<class T>
+	T map_range(T x, T in_min, T in_max, T out_min, T out_max) {
+		return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+	}
+}
+
+template<class TL, class TR>
+constexpr auto circ_add(
+	const TL& lhs, 
+	const TR& rhs, 
+	const decltype(lhs + rhs) rmin = 0, 
+	const decltype(lhs + rhs) rmax = 360)
+{
+	auto c = lhs + rhs;
+	auto range = rmax - rmin;
+	while (c >= rmax)  c -= range;
+	while (c <  rmin)  c += range;
+	return c;
+}
+
+//Converts unit distances to pixels. (Every 100 units = 24 pixels)
+long double operator""_Pixels(long double unitDist);
--- a/smx-config/App.config
+++ b/smx-config/App.config
@ -1,12 +1,12 @@
-<?xml version="1.0" encoding="utf-8" ?>
+<?xml version="1.0" encoding="utf-8"?>
 <configuration>
    <configSections>
-        <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
-            <section name="smx_config.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />
+        <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
+            <section name="smx_config.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false"/>
        </sectionGroup>
    </configSections>
    <startup> 
-        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8"/>
    </startup>
    <userSettings>
        <smx_config.Properties.Settings>
@ -14,7 +14,7 @@
                <value>False</value>
            </setting>
            <setting name="CustomSensors" serializeAs="String">
-                <value />
+                <value/>
            </setting>
            <setting name="UseInnerSensorThresholds" serializeAs="String">
                <value>False</value>
--- a/smx-config/Properties/Resources.Designer.cs
+++ b/smx-config/Properties/Resources.Designer.cs
@ -19,7 +19,7 @@ namespace smx_config.Properties {
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class Resources {
--- a/smx-config/Properties/Settings.Designer.cs
+++ b/smx-config/Properties/Settings.Designer.cs
@ -12,7 +12,7 @@ namespace smx_config.Properties {
    
    
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "15.9.0.0")]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "17.11.0.0")]
    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
        
        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
--- a/smx-config/SMXConfig.csproj
+++ b/smx-config/SMXConfig.csproj
@ -9,7 +9,7 @@
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>smx_config</RootNamespace>
    <AssemblyName>SMXConfig</AssemblyName>
-    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
    <FileAlignment>512</FileAlignment>
    <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
    <WarningLevel>4</WarningLevel>
@ -29,6 +29,7 @@
    <IsWebBootstrapper>false</IsWebBootstrapper>
    <UseApplicationTrust>false</UseApplicationTrust>
    <BootstrapperEnabled>true</BootstrapperEnabled>
+    <TargetFrameworkProfile />
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
Author	SHA1	Message	Date
sigonasr2	d9e15f93da	Fix bReleased boolean flags so they only trigger on actual release..	2025-02-20 20:29:03 -06:00
sigonasr2	1de7d840aa	Disable log messages.	2024-11-30 18:19:07 -06:00
sigonasr2	ba3cbd401d	Fix potential bug with sending too many updates too quickly. Add in input handling.	2024-11-28 05:11:31 -06:00
sigonasr2	f4ac610bdd	Begin snowfall theme.	2024-11-26 22:51:23 -06:00