sigonasr2
/
AngleNorming
generated from sigonasr2/CPlusPlusProjectTemplate
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Included angle normalizing example

Browse Source 
Co-authored-by: sigonasr2 <sigonasr2@gmail.com>
master
sigonasr2 2 years ago
parent 2830f5b550
commit 722d293fb8
2 changed files with 80 additions and 170 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. BIN
      C++ProjectTemplate
  2. 250
      main.cpp

BIN
C++ProjectTemplate
View File

Binary file not shown.

250
main.cpp
Unescape View File

@ -1,188 +1,98 @@
#define OLC_PGE_APPLICATION
#include "pixelGameEngine.h"
// PGEX Require the presence of olc::PixelGameEngine
#define OLC_PGEX_QUICKGUI
#include "quickgui.h"
#if defined(__EMSCRIPTEN__)
#include <emscripten.h>
#define FILE_RESOLVE(url, file) emscripten_wget(url, file); emscripten_sleep(0)
#else
#define FILE_RESOLVE(url, file)
#endif
namespace olc::QuickGUI{
class PictureBox : public olc::QuickGUI::BaseControl{
private:
olc::vi2d clickPos;
public:
PictureBox(olc::QuickGUI::Manager& manager, // Associate with a Manager
const olc::vf2d& pos,
const olc::vf2d& size,
const olc::vf2d& offset,
olc::Renderable& image);
using namespace olc;
public:
// Minium value
olc::vf2d offset;
olc::vf2d pos;
olc::vf2d size;
olc::Renderable&image;
public: // BaseControl overrides
void Update(olc::PixelGameEngine* pge) override;
void Draw(olc::PixelGameEngine* pge) override;
void DrawDecal(olc::PixelGameEngine* pge) override;
};
PictureBox::PictureBox(olc::QuickGUI::Manager& manager, const olc::vf2d& pos, const olc::vf2d& size, const olc::vf2d& offset,olc::Renderable& image)
: BaseControl(manager),pos(pos),size(size),offset(offset),image(image){}
void PictureBox::Update(olc::PixelGameEngine* pge)
{
bPressed = false;
bReleased = false;
float fElapsedTime = pge->GetElapsedTime();
olc::vf2d vMouse = pge->GetMousePos();
if (m_state != State::Click)
{
if (vMouse.x >= pos.x && vMouse.x < pos.x + size.x &&
vMouse.y >= pos.y && vMouse.y < pos.y + size.y)
{
m_fTransition += fElapsedTime * m_manager.fHoverSpeedOn;
m_state = State::Hover;
bPressed = pge->GetMouse(olc::Mouse::LEFT).bPressed;
if (bPressed)
{
m_state = State::Click;
clickPos = vMouse;
}
bHeld = pge->GetMouse(olc::Mouse::LEFT).bHeld;
}
else
{
m_fTransition -= fElapsedTime * m_manager.fHoverSpeedOff;
m_state = State::Normal;
}
}
else
{
bHeld = pge->GetMouse(olc::Mouse::LEFT).bHeld;
bReleased = pge->GetMouse(olc::Mouse::LEFT).bReleased;
if (bReleased) m_state = State::Normal;
offset+=clickPos-vMouse;
offset.x=std::clamp((int)offset.x,0,image.Sprite()->width-(int)size.x);
offset.y=std::clamp((int)offset.y,0,image.Sprite()->height-(int)size.y);
clickPos=vMouse;
}
}
void PictureBox::Draw(olc::PixelGameEngine* pge)
{
if (!bVisible)
return;
switch (m_state)
{
case State::Disabled: {
pge->FillRect(pos,size,m_manager.colDisable);
}break;
case State::Normal:
case State::Hover: {
pge->FillRect(pos,size,olc::PixelLerp(m_manager.colNormal, m_manager.colHover, m_fTransition));
}break;
case State::Click: {
pge->FillRect(pos,size,m_manager.colClick);
}break;
}
pge->DrawPartialSprite({(int)pos.x+1,(int)pos.y+1},image.Sprite(),offset,{(int)size.x-2,(int)size.y-2});
pge->DrawRect(pos,size,m_manager.colBorder);
}
void PictureBox::DrawDecal(olc::PixelGameEngine* pge)
{
if (!bVisible)
return;
switch (m_state)
{
case State::Disabled: {
pge->FillRectDecal(pos,size,olc::PixelLerp(m_manager.colNormal, m_manager.colHover, m_fTransition));
}break;
case State::Normal:
case State::Hover: {
pge->FillRectDecal(pos,size,olc::PixelLerp(m_manager.colNormal, m_manager.colHover, m_fTransition));
}break;
case State::Click: {
pge->FillRectDecal(pos,size,m_manager.colClick);
}break;
}
pge->DrawPartialDecal({pos.x+1,pos.y+1},image.Decal(),offset,{size.x-2,size.y-2});
pge->SetDecalMode(olc::DecalMode::WIREFRAME);
pge->DrawRectDecal(pos,size,m_manager.colBorder);
pge->SetDecalMode(olc::DecalMode::NORMAL);
}
float angle_difference(float angle_1, float angle_2)
{
angle_1=(angle_1<0)?angle_1+360:fmod(angle_1,360);
angle_2=(angle_2<0)?angle_2+360:fmod(angle_2,360);
float angle_diff = angle_1-angle_2;
if (abs(angle_diff)>180) {
if (angle_1>180) {
angle_1-=360;
}
if (angle_2>180) {
angle_2-=360;
}
angle_diff = angle_1-angle_2;
}
return -angle_diff;
}
//Points an angle from point1 to point2, returning an angle between 0-2*PI.
// (atan2 returns -PI to PI)
float atan2fmod(vd2d point1,vd2d point2){
float angle = atan2f(point2.y-point1.y,point2.x-point1.x);
if (angle<0) {
angle+=2*3.14159f;
}
return angle;
}
class Object{
public:
float facing_dir;
float rotation_spd;
vd2d pos;
vd2d size;
Object(vd2d pos, vd2d size, float rotation_spd=100*(3.14159f/180.f), float facing_dir=0)
:pos(pos),size(size),rotation_spd(rotation_spd),facing_dir(facing_dir) {}
void draw(PixelGameEngine*pge) {
pge->DrawCircle(pos,size.x);
pge->DrawLine(pos,{(int)(pos.x+4*cos(facing_dir)),(int)(pos.y+4*sin(facing_dir))});
}
};
class olcDemo_QuickGUI : public olc::PixelGameEngine
// Override base class with your custom functionality
class Example : public olc::PixelGameEngine
{
public:
olcDemo_QuickGUI()
{
sAppName = "olcDemo_QuickGUI";
}
protected:
olc::QuickGUI::Manager guiManager;
olc::QuickGUI::PictureBox* pictureBox = nullptr;
olc::QuickGUI::Slider* pictureBoxSliderX = nullptr;
olc::QuickGUI::Slider* pictureBoxSliderY = nullptr;
olc::Renderable dirtimg;
Example()
{
// Name your application
sAppName = "Rotation";
}
public:
bool OnUserCreate() override
{
dirtimg.Load("dirtblock.png");
pictureBox = new olc::QuickGUI::PictureBox(guiManager,
{ 10.0f, 10.0f }, { 128.0f, 128.0f }, {0,0}, dirtimg);
pictureBoxSliderX = new olc::QuickGUI::Slider(guiManager,{pictureBox->pos.x,pictureBox->pos.y+pictureBox->size.y+16},{pictureBox->pos.x+pictureBox->size.x,pictureBox->pos.y+pictureBox->size.y+16},
0,pictureBox->image.Sprite()->width-(int)pictureBox->size.x,pictureBox->offset.x);
pictureBoxSliderY = new olc::QuickGUI::Slider(guiManager,{pictureBox->pos.x+pictureBox->size.x+16,pictureBox->pos.y},{pictureBox->pos.x+pictureBox->size.x+16,pictureBox->pos.y+pictureBox->size.y},
0,pictureBox->image.Sprite()->height-(int)pictureBox->size.y,pictureBox->offset.y);
guiManager.AddControl(pictureBox);
guiManager.AddControl(pictureBoxSliderX);
return true;
}
bool OnUserUpdate(float fElapsedTime) override
{
guiManager.Update(this);
if (pictureBoxSliderX->bHeld) {
pictureBox->offset.x=pictureBoxSliderX->fValue;
} else {
pictureBoxSliderX->fValue=pictureBox->offset.x;
}
if (pictureBoxSliderY->bHeld) {
pictureBox->offset.y=pictureBoxSliderY->fValue;
} else {
pictureBoxSliderY->fValue=pictureBox->offset.y;
Object*testRotationObj;
bool OnUserCreate() override
{
testRotationObj = new Object({(double)ScreenWidth()/2,(double)ScreenHeight()/2},{8,8});
return true;
}
bool OnUserUpdate(float fElapsedTime) override
{
Clear(BLACK);
float diffAng = atan2fmod(testRotationObj->pos,GetMousePos());
float rotAngle=angle_difference((180.f/3.14159f)*testRotationObj->facing_dir,(180.f/3.14159f)*diffAng);
//std::cout<<diffAng<<std::endl;
//std::cout<<" "<<rotAngle<<std::endl;
if (abs(rotAngle)>testRotationObj->rotation_spd*fElapsedTime*(180.f/3.14159f)) {
if (rotAngle>0) {
testRotationObj->facing_dir+=testRotationObj->rotation_spd*fElapsedTime;
} else {
testRotationObj->facing_dir-=testRotationObj->rotation_spd*fElapsedTime;
}
}
// Draw Stuff!
Clear(olc::BLACK);
guiManager.DrawDecal(this);
return true;
}
testRotationObj->draw(this);
return true;
}
};
int main()
{
olcDemo_QuickGUI demo;
if (demo.Construct(256, 240, 4, 4))
demo.Start();
return 0;
Example demo;
if (demo.Construct(256, 240, 2, 2))
demo.Start();
return 0;
}
Write Preview
Loading…
Cancel
Save