- added q to drop items, as objects
- chests snag dropped objects, right click to reclaim
- control setting is good, needs saving though
+
+
+
+
+10/10/2016:
+===========
+
+ THE REVIVAL
+
+ - began to implement EntityX
+ - things will actually start to work
+ - created render.cpp, moved shader management to there
+ - this game will be kinda decent now???
+ - input bugs, because we're awful
ifeq ($(TARGET_OS),linux)
LIBS = -lpthread -lGL -lGLEW -lfreetype \
- -lSDL2 -lSDL2_image -lSDL2_mixer -lSDL2main
+ -lSDL2 -lSDL2_image -lSDL2_mixer -lSDL2main -lentityx
endif
ifeq ($(TARGET_OS),win32)
LIBS = -lopengl32 -lglew32 -lmingw32 \
#undef near
#endif
-// Enables special message printing in the case of segfault debugging (unnecessary?)
-//#define SEGFAULT
-
-#ifdef SEGFAULT
-#define C(x) std::cout << x << '\n'
-#else
-#define C(x)
-#endif
-
/**
* Prints a formatted string to the terminal with file and line number, for debugging
*/
* Creates a coordinate of integers.
*/
typedef struct {
- int x; /**< The x coordinate */
+ int x; /**< The x coordinate */
int y; /**< The y coordinate */
} ivec2;
*/
std::vector<std::string> StringTokenizer(const std::string& str, char delim);
-/**
- * A function used to tell the program what shader, attributes, and uniforms
- * we want to draw our rectangles to.
- *
- * @see drawRect
- * @param the shader
- * @param the 'texture uniform'
- * @param the 'coord attribute'
- * @param the 'texture coord attribute'
- */
-void useShader(GLuint *sh, GLint *tu, GLint *ca, GLint *ta);
-
/**
* A function to draw a colored box for OpenGL.
* To use it, the lower left hand and upper right hand coords are given.
belongsTo = false;
following = nullptr;
- flame = false;
+ flame = false;
}
Light(vec2 l, float r, Color c)
{
flame = true;
}
-
+
void createFromXML(XMLElement *e);
};
virtual void createFromXML(XMLElement *e, World *w=nullptr) =0;
virtual void saveToXML(void) =0;
-/* Entity
+/* Entity
**
* Forces the given entity to follow this one.
return (Merchant *)e;
}
+#include <entityx/entityx.h>
+#include <events.hpp>
+
+class PlayerSystem : public entityx::System<PlayerSystem>, public entityx::Receiver<PlayerSystem> {
+private:
+ Player **m_Player;
+ bool m_MoveLeft, m_MoveRight;
+
+public:
+ PlayerSystem(Player **p)
+ : m_Player(p), m_MoveLeft(false), m_MoveRight(false) {}
+
+ void update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt) override;
+
+ void configure(entityx::EventManager &ev);
+ void receive(const KeyDownEvent &kde);
+ void receive(const KeyUpEvent &kue);
+};
+
+
#endif // ENTITIES_H
/**
--- /dev/null
+#ifndef EVENTS_HPP_
+#define EVENTS_HPP_
+
+/**
+ * A place for events to live, while gamedev slowly dies from rewriting.
+ */
+
+#include <SDL2/SDL.h>
+
+ struct MouseScrollEvent {
+ MouseScrollEvent(int sd)
+ : scrollDistance(sd) {}
+
+ int scrollDistance;
+ };
+
+struct KeyDownEvent {
+ KeyDownEvent(SDL_Keycode kc)
+ : keycode(kc) {}
+
+ SDL_Keycode keycode;
+};
+
+struct KeyUpEvent {
+ KeyUpEvent(SDL_Keycode kc)
+ : keycode(kc) {}
+
+ SDL_Keycode keycode;
+};
+
+#endif // EVENTS_HPP_
#include <string.h>
#include <texture.hpp>
+#include <events.hpp>
#define DEBUG
float getItemWidth(std::string name);
float getItemHeight(std::string name);
+#include <entityx/entityx.h>
+
+class InventorySystem : public entityx::System<InventorySystem>, public entityx::Receiver<InventorySystem> {
+public:
+ void update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt) override;
+
+ void configure(entityx::EventManager &em);
+ void receive(const MouseScrollEvent &mse);
+};
+
#endif // INVENTORY_H
--- /dev/null
+#ifndef RENDER_HPP_
+#define RENDER_HPP_
+
+#include <vector>
+
+#include <GL/glew.h>
+#include <SDL2/SDL_opengl.h>
+
+#include <common.hpp>
+#include <shader_utils.hpp>
+
+/**
+ * @class Shader
+ * @brief Handles a texture shader, allowing it's use in the program.
+ */
+class Shader {
+public:
+ GLuint shader;
+ GLint coord;
+ GLint tex;
+ std::vector<GLint> uniform;
+
+ void create(const char *vert, const char *frag) {
+ shader = create_program(vert, frag);
+ coord = get_attrib(shader, "coord2d");
+ tex = get_attrib(shader, "tex_coord");
+ }
+
+ inline void addUniform(const char *name) {
+ uniform.push_back(get_uniform(shader, name));
+ }
+
+ inline void use(void) {
+ glUseProgram(shader);
+ }
+
+ inline void unuse(void) {
+ glUseProgram(0);
+ }
+
+ inline void enable(void) {
+ glEnableVertexAttribArray(coord);
+ glEnableVertexAttribArray(tex);
+ }
+
+ inline void disable(void) {
+ glDisableVertexAttribArray(coord);
+ glDisableVertexAttribArray(tex);
+ }
+
+ ~Shader(void) {
+ uniform.clear();
+ }
+};
+
+typedef enum {
+ WU_texture = 0,
+ WU_ortho,
+ WU_tex_color,
+ WU_transform,
+ WU_ambient,
+ WU_light_impact,
+ WU_light,
+ WU_light_color,
+ WU_light_size
+} WorldUniform;
+
+namespace Render {
+ extern Shader worldShader;
+ extern Shader textShader;
+
+ void initShaders(void);
+
+ void useShader(Shader *s);
+
+ void drawRect(vec2 ll, vec2 ur, float z);
+}
+
+#endif // RENDER_HPP_
void setControl(unsigned int index, SDL_Keycode key);
SDL_Keycode getControl(unsigned int index);
+#include <entityx/entityx.h>
+
+class InputSystem : public entityx::System<InputSystem> {
+public:
+ void update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt) override;
+};
+
namespace ui {
+ extern bool fadeEnable;
+ extern int fadeIntensity;
+
// the pixel-coordinates of the mouse
extern vec2 mouse;
void toggleWhite(void);
void toggleWhiteFast(void);
void waitForCover(void);
+ void waitForUncover(void);
}
--- /dev/null
+#ifndef WINDOW_HPP_
+#define WINDOW_HPP_
+
+#include <entityx/entityx.h>
+
+#include <SDL2/SDL.h>
+
+class WindowSystem : public entityx::System<WindowSystem> {
+private:
+ SDL_Window *window;
+ SDL_GLContext glContext;
+
+public:
+ WindowSystem(void);
+ ~WindowSystem(void);
+
+ void update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt) override;
+};
+
+#endif // WINDOW_HPP_
#include <brice.hpp>
+#include <entityx/entityx.h>
+
+#include <window.hpp>
+#include <render.hpp>
+
// local library includes
#include <tinyxml2.h>
using namespace tinyxml2;
** Variables section
** --------------------------------------------------------------------------*/
-// the game's window title name
-constexpr const char *GAME_NAME = "Independent Study v0.8 alpha - NOW WITH decent shaders";
-
-// SDL's window object
-SDL_Window *window = NULL;
-
// main loop runs based on this variable's value
bool gameRunning = true;
// the player object
Player *player;
-/**
- * These are the source and index variables for our shader
- * used to draw text and ui elements
- */
-
-GLuint textShader;
-GLint textShader_attribute_coord;
-GLint textShader_attribute_tex;
-GLint textShader_uniform_texture;
-GLint textShader_uniform_transform;
-GLint textShader_uniform_color;
-
-/**
- * These are the source and index variables for the world
- * shader which is used to draw the world items and shade them
- */
-
-GLuint worldShader;
-GLint worldShader_attribute_coord;
-GLint worldShader_attribute_tex;
-GLint worldShader_uniform_texture;
-GLint worldShader_uniform_texture_normal;
-GLint worldShader_uniform_transform;
-GLint worldShader_uniform_ortho;
-GLint worldShader_uniform_color;
-GLint worldShader_uniform_ambient;
-GLint worldShader_uniform_light;
-GLint worldShader_uniform_light_color;
-GLint worldShader_uniform_light_impact;
-GLint worldShader_uniform_light_amt;
-
// the ambient light of the current world
Color ambient;
** MAIN ************************************************************************
********************************************************************************/
+class Engine : public entityx::EntityX {
+public:
+ explicit Engine(void) {}
+
+ void init(void) {
+ game::config::read();
+ systems.add<WindowSystem>();
+ systems.add<InputSystem>();
+ systems.add<InventorySystem>();
+ systems.add<PlayerSystem>(&player);
+
+ systems.configure();
+ }
+
+ void render(entityx::TimeDelta dt) {
+ systems.update<WindowSystem>(dt);
+ }
+
+ void update(entityx::TimeDelta dt) {
+ systems.update<InputSystem>(dt);
+ systems.update<InventorySystem>(dt);
+ systems.update<PlayerSystem>(dt);
+
+ currentWorld->update(player, dt);
+ currentWorld->detect(player);
+ }
+};
+
+Engine engine;
+
int main(int argc, char *argv[])
{
- static SDL_GLContext mainGLContext = NULL;
static bool worldReset = false, worldDontReallyRun = false;
std::string worldActuallyUseThisXMLFile;
}
}
- // attempt to initialize SDL
- if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_JOYSTICK) != 0)
- UserError(std::string("SDL was not able to initialize! Error: ") + SDL_GetError());
- atexit(SDL_Quit);
-
- SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
- SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
-
- // attempt to initialize SDL_image
- if (!(IMG_Init(IMG_INIT_PNG | IMG_INIT_JPG) & (IMG_INIT_PNG | IMG_INIT_JPG)))
- UserError(std::string("Could not init image libraries! Error: ") + IMG_GetError());
- atexit(IMG_Quit);
-
- // attempt to initialize SDL_mixer
- if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048) < 0)
- UserError(std::string("SDL_mixer could not initialize! Error: ") + Mix_GetError());
- Mix_AllocateChannels(8);
- atexit(Mix_Quit);
-
- // update values by reading the config file (config/settings.xml)
- game::config::read();
-
- // create the SDL window object
- window = SDL_CreateWindow(GAME_NAME,
- SDL_WINDOWPOS_UNDEFINED, // Spawn the window at random (undefined) x and y coordinates
- SDL_WINDOWPOS_UNDEFINED, //
- game::SCREEN_WIDTH,
- game::SCREEN_HEIGHT,
- SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL | (game::FULLSCREEN ? SDL_WINDOW_FULLSCREEN : 0)
- );
-
- if (window == NULL)
- UserError(std::string("The window failed to generate! SDL_Error: ") + SDL_GetError());
-
- // create the OpenGL object that SDL provides
- if ((mainGLContext = SDL_GL_CreateContext(window)) == NULL)
- UserError(std::string("The OpenGL context failed to initialize! SDL_Error: ") + SDL_GetError());
+ engine.init();
// initialize GLEW
#ifndef __WIN32__
// initialize shaders
std::cout << "Initializing shaders!\n";
- /**
- * Creating the text shader and its attributes/uniforms
- */
- textShader = create_program("shaders/new.vert", "shaders/new.frag");
-
- textShader_attribute_coord = get_attrib(textShader, "coord2d");
- textShader_attribute_tex = get_attrib(textShader, "tex_coord");
-
- textShader_uniform_texture = get_uniform(textShader, "sampler");
- textShader_uniform_transform = get_uniform(textShader, "ortho");
- textShader_uniform_color = get_uniform(textShader, "tex_color");
-
- /**
- * Creating the world's shader and its attributes/uniforms
- */
- worldShader = create_program("shaders/world.vert", "shaders/world.frag");
-
- worldShader_attribute_coord = get_attrib(worldShader, "coord2d");
- worldShader_attribute_tex = get_attrib(worldShader, "tex_coord");
-
- worldShader_uniform_texture = get_uniform(worldShader, "texture");
- worldShader_uniform_texture_normal = get_uniform(worldShader, "normalTex");
- worldShader_uniform_transform = get_uniform(worldShader, "transform");
- worldShader_uniform_ortho = get_uniform(worldShader, "ortho");
- worldShader_uniform_color = get_uniform(worldShader, "tex_color");
- worldShader_uniform_ambient = get_uniform(worldShader, "ambientLight");
- worldShader_uniform_light = get_uniform(worldShader, "light");
- worldShader_uniform_light_color = get_uniform(worldShader, "lightColor");
- worldShader_uniform_light_impact = get_uniform(worldShader, "lightImpact");
- worldShader_uniform_light_amt = get_uniform(worldShader, "lightSize");
-
- //glEnable(GL_MULTISAMPLE);
+ // create shaders
+ Render::initShaders();
// load up some fresh hot brice
game::briceLoad();
// load mouse texture, and other inventory textures
mouseTex = Texture::loadTexture("assets/mouse.png");
- // spawn the player
player = new Player();
player->sspawn(0,100);
}).detach();
while (gameRunning) {
+ engine.render(0);
render();
ui::handleEvents();
}
ui::destroyFonts();
Texture::freeTextures();
- SDL_GL_DeleteContext(mainGLContext);
- SDL_DestroyWindow(window);
-
// close up the game stuff
currentWorld->save();
delete arena;
if (game::time::tickHasPassed())
logic();
- currentWorld->update(player, game::time::getDeltaTime());
- currentWorld->detect(player);
+ engine.update(game::time::getDeltaTime());
}
}
glEnable(GL_DEPTH_TEST);
//glEnable(GL_CULL_FACE);
- glUseProgram(textShader);
- glUniformMatrix4fv(textShader_uniform_transform, 1, GL_FALSE, glm::value_ptr(ortho));
- glUniform4f(textShader_uniform_color, 1.0, 1.0, 1.0, 1.0);
- glUseProgram(worldShader);
- glUniformMatrix4fv(worldShader_uniform_ortho, 1, GL_FALSE, glm::value_ptr(ortho));
- glUniformMatrix4fv(worldShader_uniform_transform, 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f)));
+ Render::textShader.use();
+ glUniformMatrix4fv(Render::textShader.uniform[WU_transform], 1, GL_FALSE, glm::value_ptr(ortho));
+ glUniform4f(Render::textShader.uniform[WU_tex_color], 1.0, 1.0, 1.0, 1.0);
+ Render::worldShader.use();
+ glUniformMatrix4fv(Render::worldShader.uniform[WU_ortho], 1, GL_FALSE, glm::value_ptr(ortho));
+ glUniformMatrix4fv(Render::worldShader.uniform[WU_transform], 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f)));
- glUniform4f(worldShader_uniform_color, 1.0, 1.0, 1.0, 1.0);
- glUniform4f(worldShader_uniform_ambient, ambient.red, ambient.green, ambient.blue, 1.0);
- glUniform1f(worldShader_uniform_light_impact, 1.0);
+ glUniform4f(Render::worldShader.uniform[WU_tex_color], 1.0, 1.0, 1.0, 1.0);
+ glUniform4f(Render::worldShader.uniform[WU_ambient], ambient.red, ambient.green, ambient.blue, 1.0);
+ glUniform1f(Render::worldShader.uniform[WU_light_impact], 1.0);
/*static GLfloat l[] = {460.0, 100.0, 0.0, 300.0};
static GLfloat lc[] = {1.0, 1.0, 1.0, 1.0};
GLfloat tpoint[es * 2 * 5];
GLfloat *tp = &tpoint[0];
- glUseProgram(textShader);
+ Render::textShader.use();
glBindTexture(GL_TEXTURE_2D, tracerText);
if (ui::posFlag) {
}
}
- glEnableVertexAttribArray(worldShader_attribute_coord);
- glEnableVertexAttribArray(worldShader_attribute_coord);
+ Render::worldShader.enable();
- glVertexAttribPointer(worldShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), &tpoint[0]);
- glVertexAttribPointer(worldShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), &tpoint[3]);
+ glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), &tpoint[0]);
+ glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), &tpoint[3]);
glDrawArrays(GL_LINES, 0, es * 2);
- glDisableVertexAttribArray(worldShader_attribute_tex);
- glDisableVertexAttribArray(worldShader_attribute_tex);
- glUseProgram(0);
+ Render::worldShader.disable();
+ Render::worldShader.unuse();
}
if (currentMenu)
ui::menu::draw();
- glUseProgram(textShader);
+ Render::textShader.use();
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mouseTex);
- glUniform1i(textShader_uniform_texture, 0);
+ glUniform1i(Render::textShader.uniform[WU_texture], 0);
- glEnableVertexAttribArray(textShader_attribute_tex);
- glEnableVertexAttribArray(textShader_attribute_coord);
+ Render::textShader.enable();
glDisable(GL_DEPTH_TEST);
0.0f, 0.0f, //bottom left
};
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, mouseCoords);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, mouseTex);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, mouseCoords);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, mouseTex);
glDrawArrays(GL_TRIANGLES, 0, 6);
- glDisableVertexAttribArray(textShader_attribute_coord);
- glDisableVertexAttribArray(textShader_attribute_tex);
-
- SDL_GL_SwapWindow(window);
+ Render::textShader.disable();
}
void logic(){
return tokens;
}
-static GLuint *Gshader;
-static GLint *tex_uni;
-static GLint *coord_attrib;
-static GLint *tex_attrib;
-
-void useShader(GLuint *sh, GLint *tu, GLint *ca, GLint *ta)
-{
- Gshader = sh;
- tex_uni = tu;
- coord_attrib = ca;
- tex_attrib = ta;
-}
-
-void drawRect(vec2 ll, vec2 ur, float z)
-{
- GLfloat verts[] = {ll.x, ll.y, z,
- ur.x, ll.y, z,
- ur.x, ur.y, z,
-
- ur.x, ur.y, z,
- ll.x, ur.y, z,
- ll.x, ll.y, z};
-
- GLfloat tex[] = {0.0, 1.0,
- 1.0, 1.0,
- 1.0, 0.0,
-
- 1.0, 0.0,
- 0.0, 0.0,
- 0.0, 1.0};
-
- glUniform1i(*tex_uni, 0);
-
- glEnableVertexAttribArray(*coord_attrib);
- glEnableVertexAttribArray(*tex_attrib);
-
- glVertexAttribPointer(*coord_attrib, 3, GL_FLOAT, GL_FALSE, 0, verts);
- glVertexAttribPointer(*tex_attrib, 2, GL_FLOAT, GL_FALSE, 0, tex);
- glDrawArrays(GL_TRIANGLES, 0, 6);
-
- glDisableVertexAttribArray(*tex_attrib);
- glDisableVertexAttribArray(*coord_attrib);
-}
-
void DEBUG_prints(const char* file, int line, const char *s,...)
{
va_list args;
#else
HANDLE dirh;
WIN32_FIND_DATA file_data;
-
+
if ((dirh = FindFirstFile((dir + "/*").c_str(), &file_data)) == INVALID_HANDLE_VALUE)
return -1; /* No files found */
if (is_directory)
continue;
-
+
files.push_back(file_name);
} while (FindNextFile(dirh, &file_data));
#include <gametime.hpp>
#include <brice.hpp>
+#include <render.hpp>
+
extern std::istream *names;
extern Player *player; // main.cpp
static std::vector<std::string> randomDialog (readFileA("assets/dialog_en-us"));
+
+void PlayerSystem::update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt)
+{
+ (void)en;
+ (void)ev;
+ (void)dt;
+
+ if (!m_MoveLeft && !m_MoveRight)
+ (*m_Player)->vel.x = 0;
+}
+
+void PlayerSystem::configure(entityx::EventManager &ev)
+{
+ ev.subscribe<KeyDownEvent>(*this);
+ ev.subscribe<KeyUpEvent>(*this);
+}
+
+extern std::array<SDL_Keycode, 6> controlMap;
+extern World *currentWorldToLeft;
+extern World *currentWorldToRight;
+extern bool gameRunning;
+extern bool inBattle;
+
+void PlayerSystem::receive(const KeyUpEvent &kue)
+{
+ auto p = *m_Player;
+ auto kc = kue.keycode;
+
+ if (kc == SDLK_ESCAPE) {
+ ui::menu::toggle();
+ p->save();
+ } else if (kc == controlMap[1]) {
+ m_MoveLeft = false;
+ } else if (kc == controlMap[2]) {
+ m_MoveRight = false;
+ } else if (kc == controlMap[3] || kc == controlMap[4]) {
+ player->speed = 1;
+ } else if (kc == controlMap[5]) {
+ if (p->inv->invHover) {
+ p->inv->invHover = false;
+ } else {
+ if (!p->inv->selected)
+ p->inv->invOpening ^= true;
+ else
+ p->inv->selected = false;
+
+ p->inv->mouseSel = false;
+ }
+
+ // disable action ui
+ ui::action::disable();
+ }
+}
+
+void PlayerSystem::receive(const KeyDownEvent &kde)
+{
+ auto p = *m_Player;
+ auto kc = kde.keycode;
+
+ auto worldSwitch = [&](const WorldSwitchInfo& wsi){
+ p->canMove = false;
+ ui::toggleBlackFast();
+ ui::waitForCover();
+ wsi.first->bgmPlay(currentWorld);
+ std::tie(currentWorld, p->loc) = wsi;
+ ui::toggleBlackFast();
+ ui::waitForUncover();
+ p->canMove = true;
+ };
+
+ if ((kc == SDLK_SPACE) && (game::canJump & p->ground)) {
+ p->loc.y += HLINES(2);
+ p->vel.y = .4;
+ p->ground = false;
+ }
+
+ if (!ui::dialogBoxExists || ui::dialogPassive) {
+ if (kc == controlMap[0]) {
+ if (inBattle) {
+ std::thread([&](void){
+ auto thing = dynamic_cast<Arena *>(currentWorld)->exitArena(p);
+ if (thing.first != currentWorld)
+ worldSwitch(thing);
+ }).detach();
+ } else if (!ui::fadeIntensity) {
+ std::thread([&](void){
+ auto thing = currentWorld->goInsideStructure(p);
+ if (thing.first != currentWorld)
+ worldSwitch(thing);
+ }).detach();
+ }
+ } else if (kc == controlMap[1]) {
+ if (!ui::fadeEnable) {
+ p->vel.x = -PLAYER_SPEED_CONSTANT;
+ if (std::stoi(game::getValue("Slow")) == 1)
+ p->vel.x /= 2.0f;
+ p->left = m_MoveLeft = true;
+ p->right = m_MoveRight = false;
+ if (currentWorldToLeft) {
+ std::thread([&](void){
+ auto thing = currentWorld->goWorldLeft(p);
+ if (thing.first != currentWorld)
+ worldSwitch(thing);
+ }).detach();
+ }
+ }
+ } else if (kc == controlMap[2]) {
+ if (!ui::fadeEnable) {
+ p->vel.x = PLAYER_SPEED_CONSTANT;
+ if (std::stoi(game::getValue("Slow")) == 1)
+ p->vel.x /= 2.0f;
+ p->right = m_MoveRight = true;
+ p->left = m_MoveLeft = false;
+ if (currentWorldToRight) {
+ std::thread([&](void){
+ auto thing = currentWorld->goWorldRight(p);
+ if (thing.first != currentWorld)
+ worldSwitch(thing);
+ }).detach();
+ }
+ }
+ } else if (kc == controlMap[3]) {
+ if (game::canSprint)
+ p->speed = 2.0f;
+ } else if (kc == controlMap[4]) {
+ p->speed = .5;
+ } else if (kc == controlMap[5]) {
+ static int heyOhLetsGo = 0;
+
+ //edown = true;
+
+ // start hover counter?
+ if (!heyOhLetsGo) {
+ heyOhLetsGo = game::time::getTickCount();
+ p->inv->mouseSel = false;
+ }
+
+ // run hover thing
+ if (game::time::getTickCount() - heyOhLetsGo >= 2 && !(p->inv->invOpen) && !(p->inv->selected)) {
+ p->inv->invHover = true;
+
+ // enable action ui
+ ui::action::enable();
+ }
+ }
+ } else if (kc == SDLK_DELETE) {
+ gameRunning = false;
+ } else if (kc == SDLK_t) {
+ game::time::tick(50);
+ }
+}
+
+
void getRandomName(Entity *e)
{
auto names = readFileA("assets/names_en-us");
// TODO use texture made for this
static GLuint thingyColor = Texture::genColor(Color(236, 238, 15));
- glUseProgram(worldShader);
-
- glEnableVertexAttribArray(worldShader_attribute_coord);
- glEnableVertexAttribArray(worldShader_attribute_tex);
+ Render::worldShader.use();
+ Render::worldShader.enable();
glBindTexture(GL_TEXTURE_2D, thingyColor);
- glVertexAttribPointer(worldShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, coords);
- glVertexAttribPointer(worldShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, tex_coord);
+ glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 0, coords);
+ glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 0, tex_coord);
glDrawArrays(GL_TRIANGLES, 0, 6);
- glDisableVertexAttribArray(worldShader_attribute_coord);
- glDisableVertexAttribArray(worldShader_attribute_tex);
-
- glUseProgram(0);
+ Render::worldShader.disable();
+ Render::worldShader.unuse();
}
}
break;
}
- glUseProgram(worldShader);
+ Render::worldShader.use();
// make the entity hit flash red
if (maxHitDuration-hitDuration) {
float flashAmt = 1-(hitDuration/maxHitDuration);
- glUniform4f(worldShader_uniform_color, 1.0, flashAmt, flashAmt, 1.0);
+ glUniform4f(Render::worldShader.uniform[WU_tex_color], 1.0, flashAmt, flashAmt, 1.0);
}
- glUniform1i(worldShader_uniform_texture, 0);
- glEnableVertexAttribArray(worldShader_attribute_coord);
- glEnableVertexAttribArray(worldShader_attribute_tex);
+ glUniform1i(Render::worldShader.uniform[WU_texture], 0);
+ Render::worldShader.enable();
- glVertexAttribPointer(worldShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, coords);
+ glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 0, coords);
if (left)
- glVertexAttribPointer(worldShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0 ,tex_coordL);
+ glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 0 ,tex_coordL);
else
- glVertexAttribPointer(worldShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0 ,tex_coord);
+ glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 0 ,tex_coord);
glDrawArrays(GL_TRIANGLES, 0, 6);
- glUniform4f(worldShader_uniform_color, 1.0, 1.0, 1.0, 1.0);
+ glUniform4f(Render::worldShader.uniform[WU_tex_color], 1.0, 1.0, 1.0, 1.0);
NOPE:
if (near && type != MOBT)
ui::putStringCentered(loc.x+width/2,loc.y-ui::fontSize-game::HLINE/2,name);
static GLuint frontH = Texture::genColor(Color(255,0,0));
static GLuint backH = Texture::genColor(Color(150,0,0));
- glUniform1i(worldShader_uniform_texture, 0);
+ glUniform1i(Render::worldShader.uniform[WU_texture], 0);
GLfloat coord_back[] = {
loc.x, loc.y + height, z + 0.1f,
0.0, 1.0,
0.0, 0.0,
};
- glVertexAttribPointer(worldShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, coord_back);
- glVertexAttribPointer(worldShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, tex);
+ glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 0, coord_back);
+ glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 0, tex);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindTexture(GL_TEXTURE_2D, frontH);
- glVertexAttribPointer(worldShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, coord_front);
- glVertexAttribPointer(worldShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, tex);
+ glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 0, coord_front);
+ glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 0, tex);
glDrawArrays(GL_TRIANGLES, 0, 6);
}
-glDisableVertexAttribArray(worldShader_attribute_coord);
-glDisableVertexAttribArray(worldShader_attribute_tex);
-
-glUseProgram(0);
+Render::worldShader.disable();
+Render::worldShader.unuse();
}
/**
#include <numeric>
#include <entities.hpp>
-#include <ui.hpp>
#include <gametime.hpp>
+#include <render.hpp>
+
#include <tinyxml2.h>
using namespace tinyxml2;
// light
} else if (strCaseCmp(name, "light")) {
-
+
ItemMap.push_back(new ItemLight());
// if type was not specified make it a base item
float angle = float(angleB/2.0f);
unsigned int a = 0;
//static vec2 mouseStart = {0,0};
- C("End define");
auto deltaTime = game::time::getDeltaTime();
auto SCREEN_WIDTH = game::SCREEN_WIDTH;
};
ui::fontTransInv = std::clamp(255 * (averagef(dfp) / range), 0ul, 255ul);
-
+
if (invOpening) {
for (auto &d : dfp) {
if (!a || dfp[a - 1] > 50)
* a = 0
*/
- C("Start drawing inventory");
if (invOpen) {
- useShader(&textShader,
- &textShader_uniform_texture,
- &textShader_attribute_coord,
- &textShader_attribute_tex);
+ Render::useShader(&Render::textShader);
for(auto &mr : massRay) {
float t = (((float)massDfp[a]/(float)massRange)*.5f);
glActiveTexture(GL_TEXTURE0);
- glUseProgram(textShader);
+ Render::textShader.use();
glBindTexture(GL_TEXTURE_2D, Texture::genColor(Color(0.0f,0.0f,0.0f, t >= 0? 255*t : 0)));
- glUniform1i(textShader_uniform_texture, 0);
+ glUniform1i(Render::textShader.uniform[WU_texture], 0);
- drawRect(vec2(mr.x-(itemWide/2), mr.y-(itemWide/2)), vec2(mr.x-(itemWide/2)+itemWide, mr.y-(itemWide/2)+itemWide), -6.0);
+ Render::drawRect(vec2(mr.x-(itemWide/2), mr.y-(itemWide/2)), vec2(mr.x-(itemWide/2)+itemWide, mr.y-(itemWide/2)+itemWide), -6.0);
glUseProgram(0);
if (!Items.empty() && a+numSlot < Items.size() && Items[a+numSlot].second) {
- glUseProgram(textShader);
+ Render::textShader.use();
glBindTexture(GL_TEXTURE_2D, Items[a+numSlot].first->tex->image[0]);//itemtex[items[a+numSlot].id]);
- glUniform4f(textShader_uniform_color, 1.0f, 1.0f, 1.0f, ((float)massDfp[a]/(float)(massRange?massRange:1))*0.8f);
+ glUniform4f(Render::textShader.uniform[WU_tex_color], 1.0f, 1.0f, 1.0f, ((float)massDfp[a]/(float)(massRange?massRange:1))*0.8f);
+
if (Items[a+numSlot].first->dim.y > Items[a+numSlot].first->dim.x) {
- drawRect(vec2(mr.x-((itemWide/2)*((float)Items[a+numSlot].first->dim.x/(float)Items[a+numSlot].first->dim.y)), mr.y-(itemWide/2)),
- vec2(mr.x+((itemWide/2)*((float)Items[a+numSlot].first->dim.x/(float)Items[a+numSlot].first->dim.y)), mr.y+(itemWide/2)), -6.1);
- }else{
- drawRect(vec2(mr.x-(itemWide/2),mr.y-(itemWide/2)*((float)Items[a+numSlot].first->dim.y/(float)Items[a+numSlot].first->dim.x)),
- vec2(mr.x-(itemWide/2),mr.y+(itemWide/2)*((float)Items[a+numSlot].first->dim.y/(float)Items[a+numSlot].first->dim.x)), -6.1);
+ Render::drawRect(vec2(mr.x-((itemWide/2)*((float)Items[a+numSlot].first->dim.x/(float)Items[a+numSlot].first->dim.y)), mr.y-(itemWide/2)),
+ vec2(mr.x+((itemWide/2)*((float)Items[a+numSlot].first->dim.x/(float)Items[a+numSlot].first->dim.y)), mr.y+(itemWide/2)), -6.1);
+ } else {
+ Render::drawRect(vec2(mr.x-(itemWide/2),mr.y-(itemWide/2)*((float)Items[a+numSlot].first->dim.y/(float)Items[a+numSlot].first->dim.x)),
+ vec2(mr.x-(itemWide/2),mr.y+(itemWide/2)*((float)Items[a+numSlot].first->dim.y/(float)Items[a+numSlot].first->dim.x)), -6.1);
}
ui::setFontColor(255,255,255,((float)massDfp[a]/(float)(massRange?massRange:1))*255);
ui::putText(mr.x-(itemWide/2)+(itemWide*.85),mr.y-(itemWide/2),"%d",Items[a+numSlot].second);
ui::setFontColor(255,255,255,255);
- glUseProgram(0);
+ Render::textShader.unuse();
}
a++;
}a=0;
float curTrans = (((float)curdfp[a]/(float)(curRange?curRange:1))*0.5f);
- glUseProgram(textShader);
+ Render::textShader.use();
glBindTexture(GL_TEXTURE_2D, Texture::genColor(Color(0.0f, 0.0f, 0.0f, curTrans >= 0 ? 255 * curTrans : 0)));
- drawRect(vec2(cr.end.x-(itemWide/2), cr.end.y-(itemWide/2)),
- vec2(cr.end.x-(itemWide/2)+itemWide,cr.end.y-(itemWide/2)+itemWide), -6.0);
- glUseProgram(0);
+ Render::drawRect(vec2(cr.end.x-(itemWide/2), cr.end.y-(itemWide/2)),
+ vec2(cr.end.x-(itemWide/2)+itemWide,cr.end.y-(itemWide/2)+itemWide), -6.0);
+ Render::textShader.unuse();
a++;
}a=0;
float t = ((float)dfp[a]/(float)(range?range:1))*0.5f;
- glUseProgram(textShader);
+ Render::textShader.use();
glBindTexture(GL_TEXTURE_2D, Texture::genColor(Color(0.0f, 0.0f, 0.0f, t >= 0 ? 255 * t : 0)));
- drawRect(vec2(r.end.x-(itemWide/2), r.end.y-(itemWide/2)),
- vec2(r.end.x-(itemWide/2)+itemWide,r.end.y-(itemWide/2)+itemWide), -6.0);
+ Render::drawRect(vec2(r.end.x-(itemWide/2), r.end.y-(itemWide/2)),
+ vec2(r.end.x-(itemWide/2)+itemWide,r.end.y-(itemWide/2)+itemWide), -6.0);
if (!Items.empty() && a < numSlot && Items[a].second) {
glBindTexture(GL_TEXTURE_2D, Items[a].first->tex->image[0]);//itemtex[items[a].id]);
- glUniform4f(textShader_uniform_color, 1.0f, 1.0f, 1.0f, ((float)dfp[a]/(float)(range?range:1))*0.8f);
+ glUniform4f(Render::textShader.uniform[WU_tex_color], 1.0f, 1.0f, 1.0f, ((float)dfp[a]/(float)(range?range:1))*0.8f);
if (Items[a].first->dim.y > Items[a].first->dim.x) {
- drawRect(vec2(r.end.x-((itemWide/2)*((float)Items[a].first->dim.x/(float)Items[a].first->dim.y)), r.end.y-(itemWide/2)),
- vec2(r.end.x+((itemWide/2)*((float)Items[a].first->dim.x/(float)Items[a].first->dim.y)), r.end.y+(itemWide/2)), -6.1);
- }else{
- drawRect(vec2(r.end.x-(itemWide/2),r.end.y-(itemWide/2)*((float)Items[a].first->dim.y/(float)Items[a].first->dim.x)),
- vec2(r.end.x+(itemWide/2),r.end.y+(itemWide/2)*((float)Items[a].first->dim.y/(float)Items[a].first->dim.x)), -6.1);
+ Render::drawRect(vec2(r.end.x-((itemWide/2)*((float)Items[a].first->dim.x/(float)Items[a].first->dim.y)), r.end.y-(itemWide/2)),
+ vec2(r.end.x+((itemWide/2)*((float)Items[a].first->dim.x/(float)Items[a].first->dim.y)), r.end.y+(itemWide/2)), -6.1);
+ } else {
+ Render::drawRect(vec2(r.end.x-(itemWide/2),r.end.y-(itemWide/2)*((float)Items[a].first->dim.y/(float)Items[a].first->dim.x)),
+ vec2(r.end.x+(itemWide/2),r.end.y+(itemWide/2)*((float)Items[a].first->dim.y/(float)Items[a].first->dim.x)), -6.1);
}
ui::setFontColor(255,255,255,((float)dfp[a]/(float)(range?range:1))*255);
ui::putStringCentered(r.end.x,r.end.y-(itemWide*.9),Items[a].first->name);//itemMap[items[a].id]->name);
ui::putText(r.end.x-(itemWide/2)+(itemWide*.85),r.end.y-(itemWide/2),"%d",Items[a].second);
ui::setFontColor(255,255,255,255);
}
- glUseProgram(0);
+ Render::textShader.unuse();
if (sel == a) {
static float sc = 1;
static bool up;
sc = 1.0;
}
float t = ((float)dfp[a]/(float)(range?range:1));
- useShader(&textShader,
- &textShader_uniform_texture,
- &textShader_attribute_coord,
- &textShader_attribute_tex);
+ Render::useShader(&Render::textShader);
- glUseProgram(textShader);
- glUniform4f(textShader_uniform_color, 1.0, 1.0, 1.0, 1.0);
+ Render::textShader.use();
+ glUniform4f(Render::textShader.uniform[WU_tex_color], 1.0, 1.0, 1.0, 1.0);
// bottom
glBindTexture(GL_TEXTURE_2D, Texture::genColor(Color(255, 255, 255, t >= 0 ? 255 * t : 0)));
- drawRect(vec2(r.end.x - (itemWide*sc)/2 - (itemWide*sc)*.09,r.end.y - (itemWide*sc)/2 - (itemWide*sc)*.09),
- vec2(r.end.x + (itemWide*sc)/2 + (itemWide*sc)*.09,r.end.y - (itemWide*sc)/2), -6.2);
+ Render::drawRect(vec2(r.end.x - (itemWide*sc)/2 - (itemWide*sc)*.09,r.end.y - (itemWide*sc)/2 - (itemWide*sc)*.09),
+ vec2(r.end.x + (itemWide*sc)/2 + (itemWide*sc)*.09,r.end.y - (itemWide*sc)/2), -6.2);
// top
glBindTexture(GL_TEXTURE_2D, Texture::genColor(Color(255, 255, 255, t >= 0 ? 255 * t : 0)));
- drawRect(vec2(r.end.x - (itemWide*sc)/2 - (itemWide*sc)*.09,r.end.y + (itemWide*sc)/2 + (itemWide*sc)*.09),
- vec2(r.end.x + (itemWide*sc)/2 + (itemWide*sc)*.09,r.end.y + (itemWide*sc)/2), -6.2);
+ Render::drawRect(vec2(r.end.x - (itemWide*sc)/2 - (itemWide*sc)*.09,r.end.y + (itemWide*sc)/2 + (itemWide*sc)*.09),
+ vec2(r.end.x + (itemWide*sc)/2 + (itemWide*sc)*.09,r.end.y + (itemWide*sc)/2), -6.2);
// left
glBindTexture(GL_TEXTURE_2D, Texture::genColor(Color(255, 255, 255, t >= 0 ? 255 * t : 0)));
- drawRect(vec2(r.end.x - (itemWide*sc)/2 - (itemWide*sc)*.09,r.end.y - (itemWide*sc)/2 - (itemWide*sc)*.09),
- vec2(r.end.x - (itemWide*sc)/2 ,r.end.y + (itemWide*sc)/2 + (itemWide*sc)*.09), -6.2);
+ Render::drawRect(vec2(r.end.x - (itemWide*sc)/2 - (itemWide*sc)*.09,r.end.y - (itemWide*sc)/2 - (itemWide*sc)*.09),
+ vec2(r.end.x - (itemWide*sc)/2 ,r.end.y + (itemWide*sc)/2 + (itemWide*sc)*.09), -6.2);
// right
glBindTexture(GL_TEXTURE_2D, Texture::genColor(Color(255, 255, 255, t >= 0 ? 255 * t : 0)));
- drawRect(vec2(r.end.x + (itemWide*sc)/2 ,r.end.y - (itemWide*sc)/2 - (itemWide*sc)*.09),
- vec2(r.end.x + (itemWide*sc)/2 + (itemWide*sc)*.09,r.end.y + (itemWide*sc)/2 + (itemWide*sc)*.09), -6.2);
+ Render::drawRect(vec2(r.end.x + (itemWide*sc)/2 ,r.end.y - (itemWide*sc)/2 - (itemWide*sc)*.09),
+ vec2(r.end.x + (itemWide*sc)/2 + (itemWide*sc)*.09,r.end.y + (itemWide*sc)/2 + (itemWide*sc)*.09), -6.2);
//glUseProgram(0);
}
a++;
}
- C("Done drawing standard inv");
} /*else if (invHover) {
static unsigned int highlight = 0;
static unsigned int thing = 0;
itemLoc.y = p->loc.y+(p->height/3);
itemLoc.x = p->left?p->loc.x-d->dim.x/2:p->loc.x+p->width-d->dim.x/2;
- glUseProgram(worldShader);
+ Render::worldShader.use();
if (p->left) {
// move to center of screen
glm::mat4 trt = glm::translate(glm::mat4(1.0f),
glm::vec3(-itemLoc.x-d->dim.x/2, -itemLoc.y, 0));
// tell shader to translate the object using steps above
- glUniformMatrix4fv(worldShader_uniform_transform, 1, GL_FALSE, glm::value_ptr(tro * rot * trt));
+ glUniformMatrix4fv(Render::worldShader.uniform[WU_transform], 1, GL_FALSE, glm::value_ptr(tro * rot * trt));
} else {
// move to center of screen
glm::mat4 tro = glm::translate(glm::mat4(1.0f),
glm::mat4 trt = glm::translate(glm::mat4(1.0f),
glm::vec3(-itemLoc.x-d->dim.x/2,-itemLoc.y,0));
// tell shader to translate the object using steps above
- glUniformMatrix4fv(worldShader_uniform_transform, 1, GL_FALSE, glm::value_ptr(tro * rot * trt));
+ glUniformMatrix4fv(Render::worldShader.uniform[WU_transform], 1, GL_FALSE, glm::value_ptr(tro * rot * trt));
}
GLfloat itemTex[12] = {0.0, 0.0,
glBindTexture(GL_TEXTURE_2D,d->tex->image[0]);
- glEnableVertexAttribArray(worldShader_attribute_coord);
- glEnableVertexAttribArray(worldShader_attribute_tex);
+ Render::worldShader.enable();
- glVertexAttribPointer(worldShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, itemCoords);
- glVertexAttribPointer(worldShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, itemTex);
+ glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 0, itemCoords);
+ glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 0, itemTex);
glDrawArrays(GL_TRIANGLES, 0, 6);
- glDisableVertexAttribArray(worldShader_attribute_coord);
- glDisableVertexAttribArray(worldShader_attribute_tex);
-
- glUseProgram(0);
+ Render::worldShader.disable();
+ Render::worldShader.unuse();
}
/*
else
return nullptr;
}
+
+void InventorySystem::update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt)
+{
+ (void)en;
+ (void)ev;
+ (void)dt;
+}
+
+void InventorySystem::configure(entityx::EventManager &em)
+{
+ em.subscribe<MouseScrollEvent>(*this);
+}
+
+void InventorySystem::receive(const MouseScrollEvent &mse)
+{
+ static int mouseWheelUpCount = 0, mouseWheelDownCount = 0;
+
+ if ((mse.scrollDistance < 0) && ((++mouseWheelUpCount % 5) == 0) ) {
+ mouseWheelUpCount = 0;
+ player->inv->setSelectionUp();
+ } else if ( (++mouseWheelDownCount % 5) == 0 ) {
+ mouseWheelDownCount = 0;
+ player->inv->setSelectionDown();
+ }
+}
--- /dev/null
+#include <render.hpp>
+
+static Shader *currentShader = nullptr;
+
+namespace Render {
+
+Shader worldShader;
+Shader textShader;
+
+void initShaders(void)
+{
+ // create the world shader
+ worldShader.create("shaders/world.vert", "shaders/world.frag");
+ worldShader.addUniform("texture");
+ worldShader.addUniform("ortho");
+ worldShader.addUniform("tex_color");
+ worldShader.addUniform("transform");
+ worldShader.addUniform("ambientLight");
+ worldShader.addUniform("lightImpact");
+ worldShader.addUniform("light");
+ worldShader.addUniform("lightColor");
+ worldShader.addUniform("lightSize");
+
+ // create the text shader
+ textShader.create("shaders/new.vert", "shaders/new.frag");
+ textShader.addUniform("sampler");
+ textShader.addUniform("ortho"); // actually not used, ortho in new.vert is mislabeled (actually transform)
+ textShader.addUniform("tex_color");
+ textShader.addUniform("ortho"); // this is transform
+}
+
+void useShader(Shader *s)
+{
+ currentShader = s;
+}
+
+void drawRect(vec2 ll, vec2 ur, float z)
+{
+ GLfloat verts[] = {ll.x, ll.y, z,
+ ur.x, ll.y, z,
+ ur.x, ur.y, z,
+
+ ur.x, ur.y, z,
+ ll.x, ur.y, z,
+ ll.x, ll.y, z};
+
+ GLfloat tex[] = {0.0, 1.0,
+ 1.0, 1.0,
+ 1.0, 0.0,
+
+ 1.0, 0.0,
+ 0.0, 0.0,
+ 0.0, 1.0};
+
+ glUniform1i(currentShader->uniform[WU_texture], 0);
+ currentShader->enable();
+
+ glVertexAttribPointer(currentShader->coord, 3, GL_FLOAT, GL_FALSE, 0, verts);
+ glVertexAttribPointer(currentShader->tex, 2, GL_FLOAT, GL_FALSE, 0, tex);
+ glDrawArrays(GL_TRIANGLES, 0, 6);
+
+ currentShader->disable();
+}
+
+
+}
#include <world.hpp>
#include <gametime.hpp>
+#include <render.hpp>
+#include <events.hpp>
+
extern Menu* currentMenu;
extern SDL_Window *window;
extern bool gameRunning;
-static std::array<SDL_Keycode, 6> controlMap = {
+std::array<SDL_Keycode, 6> controlMap = {
SDLK_w, SDLK_a, SDLK_d, SDLK_LSHIFT, SDLK_LCTRL, SDLK_e
};
* Fade effect flags
*/
-static bool fadeEnable = false;
static bool fadeWhite = false;
static bool fadeFast = false;
-static int fadeIntensity = 0;
bool inBattle = false;
Mix_Chunk *battleStart;
namespace ui {
+ bool fadeEnable = false;
+ int fadeIntensity = 0;
+
/*
* Mouse coordinates.
*/
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,(*ftex)[c-33]);
- glUniform1i(textShader_uniform_texture, 0);
+ glUniform1i(Render::textShader.uniform[WU_texture], 0);
//glDisable(GL_DEPTH_TEST);
- glUseProgram(textShader);
-
- glEnableVertexAttribArray(textShader_attribute_coord);
- glEnableVertexAttribArray(textShader_attribute_tex);
+ Render::textShader.use();
+ Render::textShader.enable();
GLfloat tex_coord[] = {
0.0, 1.0, //bottom left
c1.x, c1.y -c2.y, fontZ //bottom left
};
- glUniform4f(textShader_uniform_color,
+ glUniform4f(Render::textShader.uniform[WU_tex_color],
static_cast<float>(fontColor[0]/255),
static_cast<float>(fontColor[1]/255),
static_cast<float>(fontColor[2]/255),
static_cast<float>(fontColor[3]/255));
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, text_vert);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, tex_coord);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, text_vert);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, tex_coord);
glDrawArrays(GL_TRIANGLES, 0, 6);
- glUniform4f(textShader_uniform_color, 1.0, 1.0, 1.0, 1.0);
+ glUniform4f(Render::textShader.uniform[WU_tex_color], 1.0, 1.0, 1.0, 1.0);
- glDisableVertexAttribArray(textShader_attribute_tex);
- glDisableVertexAttribArray(textShader_attribute_coord);
-
- glUseProgram(0);
+ Render::textShader.disable();
+ Render::textShader.unuse();
//glEnable(GL_DEPTH_TEST);
va_list args;
std::unique_ptr<char[]> buf (new char[512]);
memset(buf.get(), 0, 512 * sizeof(char));
-
+
va_start(args, str);
vsnprintf(buf.get(), 512, str, args);
va_end(args);
while (fadeIntensity < 255);
fadeIntensity = 255;
}
-
+
void waitForUncover(void) {
while (fadeIntensity > 0);
fadeIntensity = 0;
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, boxT);
- glUniform1i(textShader_uniform_texture, 0);
- glUseProgram(textShader);
+ glUniform1i(Render::textShader.uniform[WU_texture], 0);
- glEnableVertexAttribArray(textShader_attribute_coord);
- glEnableVertexAttribArray(textShader_attribute_tex);
+ Render::textShader.use();
+ Render::textShader.enable();
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, box);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, box_tex);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, box);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, box_tex);
glDrawArrays(GL_TRIANGLES, 0 ,6);
glBindTexture(GL_TEXTURE_2D, lineT);
- glUniform1i(textShader_uniform_texture, 0);
+ glUniform1i(Render::textShader.uniform[WU_texture], 0);
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, line_strip);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, box_tex);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, line_strip);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, box_tex);
glDrawArrays(GL_LINE_STRIP, 0 ,8);
- glDisableVertexAttribArray(textShader_attribute_coord);
- glDisableVertexAttribArray(textShader_attribute_tex);
-
- glUseProgram(0);
+ Render::textShader.disable();
+ Render::textShader.unuse();
}
void drawNiceBox(vec2 c1, vec2 c2, float z) {
// the dimensions of the corner textures
static dim2 box_corner_dim_t = Texture::imageDim("assets/ui/button_corners.png");
static vec2 box_corner_dim = vec2(box_corner_dim_t.x / 2.0, box_corner_dim_t.y / 2.0);
-
+
// the amount of bytes to skip in the OpenGL arrays (see below)
auto stride = 5 * sizeof(GLfloat);
-
+
// we always want to make sure c1 is lower left and c2 is upper right
if (c1.x > c2.x) std::swap(c1.x, c2.y);
if (c1.y > c2.y) std::swap(c1.y, c2.y);
-
- // if the box is too small, we will not be able to draw it
+
+ // if the box is too small, we will not be able to draw it
if (c2.x - c1.x < (box_corner_dim_t.x)) return;
if (c2.y - c1.y < (box_corner_dim_t.y)) return;
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, box_corner);
- glUniform1f(textShader_uniform_texture, 0);
- glUseProgram(textShader);
+ glUniform1f(Render::textShader.uniform[WU_texture], 0);
- glEnableVertexAttribArray(textShader_attribute_coord);
- glEnableVertexAttribArray(textShader_attribute_tex);
+ Render::textShader.use();
+ Render::textShader.enable();
// draw upper left corner
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, stride, &box_ul[0]);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, stride, &box_ul[3]);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, stride, &box_ul[0]);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, stride, &box_ul[3]);
glDrawArrays(GL_TRIANGLES, 0, 6);
// lower left corner
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, stride, &box_ll[0]);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, stride, &box_ll[3]);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, stride, &box_ll[0]);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, stride, &box_ll[3]);
glDrawArrays(GL_TRIANGLES, 0, 6);
-
+
// upper right corner
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, stride, &box_ur[0]);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, stride, &box_ur[3]);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, stride, &box_ur[0]);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, stride, &box_ur[3]);
glDrawArrays(GL_TRIANGLES, 0, 6);
-
+
// lower right corner
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, stride, &box_lr[0]);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, stride, &box_lr[3]);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, stride, &box_lr[0]);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, stride, &box_lr[3]);
glDrawArrays(GL_TRIANGLES, 0, 6);
// draw the middle of the box
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, stride, &box_f[0]);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, stride, &box_f[3]);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, stride, &box_f[0]);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, stride, &box_f[3]);
glDrawArrays(GL_TRIANGLES, 0, 6);
-
+
glBindTexture(GL_TEXTURE_2D, box_side);
// draw the left edge of the box
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, stride, &box_l[0]);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, stride, &box_l[3]);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, stride, &box_l[0]);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, stride, &box_l[3]);
glDrawArrays(GL_TRIANGLES, 0, 6);
// draw right edge of the box
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, stride, &box_r[0]);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, stride, &box_r[3]);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, stride, &box_r[0]);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, stride, &box_r[3]);
glDrawArrays(GL_TRIANGLES, 0, 6);
-
+
glBindTexture(GL_TEXTURE_2D, box_side_top);
// draw bottom of the box
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, stride, &box_b[0]);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, stride, &box_b[3]);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, stride, &box_b[0]);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, stride, &box_b[3]);
glDrawArrays(GL_TRIANGLES, 0, 6);
// draw top of the box
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, stride, &box_t[0]);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, stride, &box_t[3]);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, stride, &box_t[0]);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, stride, &box_t[3]);
glDrawArrays(GL_TRIANGLES, 0, 6);
- glDisableVertexAttribArray(textShader_attribute_coord);
- glDisableVertexAttribArray(textShader_attribute_tex);
-
- glUseProgram(0);
+ Render::textShader.disable();
+ Render::textShader.unuse();
}
-
+
void draw(void){
unsigned char i;
float x,y,tmp;
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, pageTex);
- glUniform1i(textShader_uniform_texture, 0);
- glUseProgram(textShader);
+ glUniform1i(Render::textShader.uniform[WU_texture], 0);
- glEnableVertexAttribArray(textShader_attribute_coord);
- glEnableVertexAttribArray(textShader_attribute_tex);
+ Render::textShader.use();
+ Render::textShader.enable();
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, page_loc);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, page_tex);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, page_loc);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, page_tex);
glDrawArrays(GL_TRIANGLES, 0 ,6);
- glDisableVertexAttribArray(textShader_attribute_coord);
- glDisableVertexAttribArray(textShader_attribute_tex);
-
- glUseProgram(0);
+ Render::textShader.disable();
+ Render::textShader.unuse();
} else if (dialogBoxExists) {
rtext = typeOut(dialogBoxText);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, getItemTexture(merchTrade.item[1]));
- glUniform1i(textShader_uniform_texture, 0);
- glUseProgram(textShader);
+ glUniform1i(Render::textShader.uniform[WU_texture], 0);
- glEnableVertexAttribArray(textShader_attribute_coord);
- glEnableVertexAttribArray(textShader_attribute_tex);
+ Render::textShader.use();
+ Render::textShader.enable();
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, left_item);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, item_tex);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, left_item);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, item_tex);
glDrawArrays(GL_TRIANGLES, 0 ,6);
glBindTexture(GL_TEXTURE_2D, getItemTexture(merchTrade.item[0]));
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, right_item);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, item_tex);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, right_item);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, item_tex);
glDrawArrays(GL_TRIANGLES, 0 ,6);
- glDisableVertexAttribArray(textShader_attribute_coord);
- glDisableVertexAttribArray(textShader_attribute_tex);
-
- glUseProgram(0);
+ Render::textShader.disable();
+ Render::textShader.unuse();
merchArrowLoc[0].x = offset.x - (SCREEN_WIDTH / 8.5) - 16;
merchArrowLoc[1].x = offset.x + (SCREEN_WIDTH / 8.5) + 16;
merchArrowLoc[i].z, merchArrowLoc[i].y - 8, -7.1,
merchArrowLoc[i].z, merchArrowLoc[i].y + 8, -7.1};
- glUniform1i(textShader_uniform_texture, 0);
- glUseProgram(textShader);
+ glUniform1i(Render::textShader.uniform[WU_texture], 0);
- glEnableVertexAttribArray(textShader_attribute_coord);
- glEnableVertexAttribArray(textShader_attribute_tex);
+ Render::textShader.use();
+ Render::textShader.enable();
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, tri_c);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, tri_t);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, tri_c);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, tri_t);
glDrawArrays(GL_TRIANGLES, 0 ,6);
- glDisableVertexAttribArray(textShader_attribute_coord);
- glDisableVertexAttribArray(textShader_attribute_tex);
-
- glUseProgram(0);
+ Render::textShader.disable();
+ Render::textShader.unuse();
}
hub.x + 150, hub.y + 12, -7.1};
- glUniform1i(textShader_uniform_texture, 0);
- glUseProgram(textShader);
+ glUniform1i(Render::textShader.uniform[WU_texture], 0);
- glEnableVertexAttribArray(textShader_attribute_coord);
- glEnableVertexAttribArray(textShader_attribute_tex);
+ Render::textShader.use();
+ Render::textShader.enable();
glBindTexture(GL_TEXTURE_2D, frontHealth);
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, front);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, tex);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, front);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, tex);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindTexture(GL_TEXTURE_2D, backHealth);
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, back);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, tex);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, back);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, tex);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
- glDisableVertexAttribArray(textShader_attribute_coord);
- glDisableVertexAttribArray(textShader_attribute_tex);
-
- glUseProgram(0);
+ Render::textShader.disable();
+ Render::textShader.unuse();
}
/*
}
void handleEvents(void) {
- static bool left=true,right=false;
- static int heyOhLetsGo = 0;
- static int mouseWheelUpCount = 0, mouseWheelDownCount = 0;
-
- auto SCREEN_WIDTH = game::SCREEN_WIDTH;
- auto SCREEN_HEIGHT = game::SCREEN_HEIGHT;
-
- auto indoor = dynamic_cast<IndoorWorld *>(currentWorld);
- Mob *m; // ;lkjfdsa
- Entity *en; // used for interaction
-
- SDL_Event e;
-
- // update mouse coords
- mouse.x = premouse.x + offset.x - (SCREEN_WIDTH / 2);
- mouse.y = (offset.y + SCREEN_HEIGHT / 2) - premouse.y;
-
- static vec2 fr;
- static Entity *ig;
-
- auto worldSwitch = [&](const WorldSwitchInfo& wsi){
- player->canMove = false;
- toggleBlackFast();
- waitForCover();
- wsi.first->bgmPlay(currentWorld);
- std::tie(currentWorld, player->loc) = wsi;
- toggleBlackFast();
- waitForUncover();
- player->canMove = true;
- };
-
- while(SDL_PollEvent(&e)) {
- switch(e.type) {
-
- // escape - quit game
- case SDL_QUIT:
- gameRunning = false;
- break;
-
- // mouse movement - update mouse vector
- case SDL_MOUSEMOTION:
- premouse.x=e.motion.x;
- premouse.y=e.motion.y;
- break;
-
- case SDL_MOUSEBUTTONUP:
- if (ig) {
- ig->vel.x = (fr.x - mouse.x) / 50.0f;
- ig->vel.y = (fr.y - mouse.y) / 50.0f;
- //ig->forcedMove = true; // kills vel.x too quickly
- ig = NULL;
- }
- break;
-
- // mouse clicks
- case SDL_MOUSEBUTTONDOWN:
-
- // run actions?
- if ((action::make = e.button.button & SDL_BUTTON_RIGHT))
- /*player->inv->invHover =*/ edown = false;
-
- textToDraw.clear();
-
- if (dialogBoxExists || pageTexReady) {
- // right click advances dialog
- if ((e.button.button & SDL_BUTTON_RIGHT))
- dialogAdvance();
- } else {
- // left click uses item
- if (e.button.button & SDL_BUTTON_LEFT) {
- if ((en = currentWorld->getNearMob(*player)) != nullptr) {
- player->inv->currentAddInteract(en);
- }
- player->inv->useCurrent();
- }
-
- }
-
- if(mouse.x > player->loc.x && mouse.x < player->loc.x + player->width &&
- mouse.y > player->loc.y && mouse.y < player->loc.y + player->height) {
- player->vel.y = .05;
- fr = mouse;
- ig = player;
- } else {
- for (auto &e : currentWorld->entity) {
- if (mouse.x > e->loc.x && mouse.x < e->loc.x + e->width &&
- mouse.y > e->loc.y && mouse.y < e->loc.y + e->height) {
- e->vel.y = .05;
- fr = mouse;
- ig = e;
- break;
- }
- }
- }
-
- break;
- case SDL_MOUSEWHEEL:
- if (e.wheel.y < 0) {
- if (mouseWheelUpCount++ && mouseWheelUpCount%5==0) {
- player->inv->setSelectionUp();
- mouseWheelUpCount = 0;
- }
- }else{
- if (mouseWheelDownCount-- && mouseWheelDownCount%5==0) {
- player->inv->setSelectionDown();
- mouseWheelDownCount = 0;
- }
- }
- break;
- // key presses
- case SDL_KEYDOWN:
-
- // space - make player jump
- if (SDL_KEY == SDLK_SPACE && game::canJump) {
- if (player->ground) {
- player->loc.y += HLINES(2);
- player->vel.y = .4;
- player->ground = false;
- }
- break;
-
- // only let other keys be handled if dialog allows it
- } else if (!dialogBoxExists || dialogPassive) {
- if (SDL_KEY == controlMap[0]) {
- if (inBattle) {
- std::thread([&](void){
- auto thing = dynamic_cast<Arena *>(currentWorld)->exitArena(player);
- if (thing.first != currentWorld)
- worldSwitch(thing);
- }).detach();
- } else if (!fadeIntensity) {
- std::thread([&](void){
- auto thing = currentWorld->goInsideStructure(player);
- if (thing.first != currentWorld)
- worldSwitch(thing);
- }).detach();
- }
- } else if (SDL_KEY == controlMap[1]) {
- if (!fadeEnable) {
- player->vel.x = -PLAYER_SPEED_CONSTANT;
- if (std::stoi(game::getValue("Slow")) == 1)
- player->vel.x /= 2.0f;
- player->left = left = true;
- player->right = right = false;
- if (currentWorldToLeft) {
- std::thread([&](void){
- auto thing = currentWorld->goWorldLeft(player);
- if (thing.first != currentWorld)
- worldSwitch(thing);
- }).detach();
- }
- }
- } else if (SDL_KEY == controlMap[2]) {
- if (!fadeEnable) {
- player->vel.x = PLAYER_SPEED_CONSTANT;
- if (std::stoi(game::getValue("Slow")) == 1)
- player->vel.x /= 2.0f;
- player->right = right = true;
- player->left = left = false;
- if (currentWorldToRight) {
- std::thread([&](void){
- auto thing = currentWorld->goWorldRight(player);
- if (thing.first != currentWorld)
- worldSwitch(thing);
- }).detach();
- }
- }
- } else if (SDL_KEY == controlMap[3]) {
- if (game::canSprint) {
- if (debug) {
- Mix_PlayChannel(1, sanic, -1);
- player->speed = 4.0f;
- } else {
- player->speed = 2.0f;
- }
- }
- } else if (SDL_KEY == controlMap[4]) {
- player->speed = .5;
- } else if (SDL_KEY == controlMap[5]) {
- edown = true;
-
- // start hover counter?
- if (!heyOhLetsGo) {
- heyOhLetsGo = game::time::getTickCount();
- player->inv->mouseSel = false;
- }
-
- // run hover thing
- if (game::time::getTickCount() - heyOhLetsGo >= 2 && !(player->inv->invOpen) && !(player->inv->selected)) {
- player->inv->invHover = true;
-
- // enable action ui
- action::enable();
- }
- } else switch(SDL_KEY) {
- case SDLK_DELETE:
- gameRunning = false;
- break;
- case SDLK_t:
- game::time::tick(50);
- break;
- default:
- break;
- }
- }
- break;
- /*
- * KEYUP
- */
-
- case SDL_KEYUP:
- if (SDL_KEY == SDLK_ESCAPE) {
- ui::menu::toggle();
- player->save();
- return;
- } else if (SDL_KEY == controlMap[1]) {
- left = false;
- } else if (SDL_KEY == controlMap[2]) {
- right = false;
- } else if (SDL_KEY == controlMap[3]) {
- if (player->speed == 4)
- Mix_FadeOutChannel(1, 2000);
-
- player->speed = 1;
- } else if (SDL_KEY == controlMap[4]) {
- player->speed = 1;
- } else if (SDL_KEY == controlMap[5]) {
- edown = false;
-
- if (player->inv->invHover) {
- player->inv->invHover = false;
- } else {
- if (!player->inv->selected)
- player->inv->invOpening ^= true;
- else
- player->inv->selected = false;
-
- player->inv->mouseSel = false;
- }
-
- // disable action ui
- action::disable();
-
- heyOhLetsGo = 0;
- } else if (SDL_KEY == SDLK_q) {
- auto item = player->inv->getCurrentItem();
- if (item != nullptr) {
- if (player->inv->takeItem(item->name, 1) == 0)
- currentWorld->addObject(item->name, "o shit waddup",
- player->loc.x + player->width / 2, player->loc.y + player->height / 2);
- }
- } else if (SDL_KEY == SDLK_h) {
- quest::toggle();
- } else switch (SDL_KEY) {
- case SDLK_F3:
- debug ^= true;
- break;
- case SDLK_BACKSLASH:
- dialogBoxExists = false;
- break;
- case SDLK_x:
- m = currentWorld->getNearMob(*player);
- if (m != nullptr)
- m->ride(player);
- break;
- case SDLK_i:
- if (indoor && indoor->isFloorAbove(player)) {
- player->loc.y += INDOOR_FLOOR_HEIGHT;
- player->ground = false;
- }
- break;
- case SDLK_k:
- if (indoor && indoor->isFloorBelow(player)) {
- player->loc.y -= INDOOR_FLOOR_HEIGHT;
- player->ground = false;
- }
- break;
- case SDLK_l:
- currentWorld->addLight({player->loc.x + SCREEN_WIDTH/2, player->loc.y}, 300.0f, {1.0f,1.0f,1.0f});
- currentWorld->getLastLight().follow(player);
- currentWorld->getLastLight().makeFlame();
- break;
- case SDLK_f:
- currentWorld->addLight({player->loc.x, player->loc.y}, 300.0f, {1.0f,1.0f,1.0f});
- break;
- case SDLK_b:
- if (debug)
- posFlag ^= true;
- else {
- auto s = new Structures();
- s->spawn(FIRE_PIT, player->loc.x, player->loc.y);
- //currentWorld->addStructure(s);
- //currentWorld->addLight({player->loc.x + SCREEN_WIDTH/2, player->loc.y}, 400.0f, {1.0f,1.0f,1.0f});
- //currentWorld->getLastLight()->follow(currentWorld->build.back());
- //currentWorld->getLastLight()->makeFlame();
- }
- break;
- case SDLK_F12:
- // Make the BYTE array, factor of 3 because it's RBG.
- static GLubyte* pixels;
- pixels = new GLubyte[ 3 * SCREEN_WIDTH * SCREEN_HEIGHT];
- glReadPixels(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, GL_RGB, GL_UNSIGNED_BYTE, pixels);
- takeScreenshot(pixels);
-
- std::cout << "Took screenshot" << std::endl;
- break;
- case SDLK_UP:
- player->inv->setSelectionUp();
- break;
- case SDLK_DOWN:
- player->inv->setSelectionDown();
- break;
- default:
- break;
- }
-
- if (!left&&!right)
- player->vel.x=0;
-
- break;
- default:
- break;
- }
- }
-
// Flush preloaded AI functions if necessary
if (!dialogBoxExists) {
while (!aipreload.empty()) {
void drawFade(void) {
auto SCREEN_WIDTH = game::SCREEN_WIDTH;
auto SCREEN_HEIGHT = game::SCREEN_HEIGHT;
-
+
if (!fadeIntensity) {
if (fontSize != 16)
setFontSize(16);
offset.x + SCREEN_WIDTH / 2, offset.y - SCREEN_HEIGHT / 2, -7.9,
offset.x - SCREEN_WIDTH / 2 - 1, offset.y + SCREEN_HEIGHT / 2, -7.9,
offset.x + SCREEN_WIDTH / 2, offset.y + SCREEN_HEIGHT / 2, -7.9};
-
+
setFontZ(-8.2);
- glUniform1i(textShader_uniform_texture, 0);
- glUseProgram(textShader);
+ glUniform1i(Render::textShader.uniform[WU_texture], 0);
- glEnableVertexAttribArray(textShader_attribute_coord);
- glEnableVertexAttribArray(textShader_attribute_tex);
+ Render::textShader.use();
+ Render::textShader.enable();
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, backdrop);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, tex);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, backdrop);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, tex);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
- glDisableVertexAttribArray(textShader_attribute_coord);
- glDisableVertexAttribArray(textShader_attribute_tex);
+ Render::textShader.disable();
+ Render::textShader.unuse();
- glUseProgram(0);
setFontZ(-8.0);
}
fclose(bmp);
}
}
+
+using namespace ui;
+
+void InputSystem::update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt)
+{
+ (void)en;
+ (void)ev;
+ (void)dt;
+
+
+ auto SCREEN_WIDTH = game::SCREEN_WIDTH;
+ auto SCREEN_HEIGHT = game::SCREEN_HEIGHT;
+
+ auto indoor = dynamic_cast<IndoorWorld *>(currentWorld);
+ Mob *m; // ;lkjfdsa
+ Entity *ent; // used for interaction
+
+ SDL_Event e;
+
+ // update mouse coords
+ mouse.x = premouse.x + offset.x - (SCREEN_WIDTH / 2);
+ mouse.y = (offset.y + SCREEN_HEIGHT / 2) - premouse.y;
+
+ static vec2 fr;
+ static Entity *ig;
+
+ while(SDL_PollEvent(&e)) {
+ switch(e.type) {
+
+ // escape - quit game
+ case SDL_QUIT:
+ gameRunning = false;
+ break;
+
+ // mouse movement - update mouse vector
+ case SDL_MOUSEMOTION:
+ premouse.x=e.motion.x;
+ premouse.y=e.motion.y;
+ break;
+
+ case SDL_MOUSEBUTTONUP:
+ if (ig) {
+ ig->vel.x = (fr.x - mouse.x) / 50.0f;
+ ig->vel.y = (fr.y - mouse.y) / 50.0f;
+ //ig->forcedMove = true; // kills vel.x too quickly
+ ig = NULL;
+ }
+ break;
+
+ // mouse clicks
+ case SDL_MOUSEBUTTONDOWN:
+
+ // run actions?
+ if ((action::make = e.button.button & SDL_BUTTON_RIGHT))
+ /*player->inv->invHover =*/ edown = false;
+
+ textToDraw.clear();
+
+ if (dialogBoxExists || pageTexReady) {
+ // right click advances dialog
+ if ((e.button.button & SDL_BUTTON_RIGHT))
+ dialogAdvance();
+ } else {
+ // left click uses item
+ if (e.button.button & SDL_BUTTON_LEFT) {
+ if ((ent = currentWorld->getNearMob(*player)) != nullptr) {
+ player->inv->currentAddInteract(ent);
+ }
+ player->inv->useCurrent();
+ }
+
+ }
+
+ if(mouse.x > player->loc.x && mouse.x < player->loc.x + player->width &&
+ mouse.y > player->loc.y && mouse.y < player->loc.y + player->height) {
+ player->vel.y = .05;
+ fr = mouse;
+ ig = player;
+ } else {
+ for (auto &e : currentWorld->entity) {
+ if (mouse.x > e->loc.x && mouse.x < e->loc.x + e->width &&
+ mouse.y > e->loc.y && mouse.y < e->loc.y + e->height) {
+ e->vel.y = .05;
+ fr = mouse;
+ ig = e;
+ break;
+ }
+ }
+ }
+
+ break;
+
+ case SDL_MOUSEWHEEL:
+ ev.emit<MouseScrollEvent>(e.wheel.y);
+ break;
+
+ // key presses
+ case SDL_KEYDOWN:
+ ev.emit<KeyDownEvent>(SDL_KEY);
+ break;
+ /*
+ * KEYUP
+ */
+
+ case SDL_KEYUP:
+ ev.emit<KeyUpEvent>(SDL_KEY);
+
+ if (SDL_KEY == SDLK_q) {
+ auto item = player->inv->getCurrentItem();
+ if (item != nullptr) {
+ if (player->inv->takeItem(item->name, 1) == 0)
+ currentWorld->addObject(item->name, "o shit waddup",
+ player->loc.x + player->width / 2, player->loc.y + player->height / 2);
+ }
+ } else if (SDL_KEY == SDLK_h) {
+ quest::toggle();
+ } else switch (SDL_KEY) {
+ case SDLK_F3:
+ debug ^= true;
+ break;
+ case SDLK_BACKSLASH:
+ dialogBoxExists = false;
+ break;
+ case SDLK_x:
+ m = currentWorld->getNearMob(*player);
+ if (m != nullptr)
+ m->ride(player);
+ break;
+ case SDLK_i:
+ if (indoor && indoor->isFloorAbove(player)) {
+ player->loc.y += INDOOR_FLOOR_HEIGHT;
+ player->ground = false;
+ }
+ break;
+ case SDLK_k:
+ if (indoor && indoor->isFloorBelow(player)) {
+ player->loc.y -= INDOOR_FLOOR_HEIGHT;
+ player->ground = false;
+ }
+ break;
+ case SDLK_l:
+ currentWorld->addLight({player->loc.x + SCREEN_WIDTH/2, player->loc.y}, 300.0f, {1.0f,1.0f,1.0f});
+ currentWorld->getLastLight().follow(player);
+ currentWorld->getLastLight().makeFlame();
+ break;
+ case SDLK_f:
+ currentWorld->addLight({player->loc.x, player->loc.y}, 300.0f, {1.0f,1.0f,1.0f});
+ break;
+ case SDLK_b:
+ if (debug)
+ posFlag ^= true;
+ else {
+ auto s = new Structures();
+ s->spawn(FIRE_PIT, player->loc.x, player->loc.y);
+ //currentWorld->addStructure(s);
+ //currentWorld->addLight({player->loc.x + SCREEN_WIDTH/2, player->loc.y}, 400.0f, {1.0f,1.0f,1.0f});
+ //currentWorld->getLastLight()->follow(currentWorld->build.back());
+ //currentWorld->getLastLight()->makeFlame();
+ }
+ break;
+ case SDLK_F12:
+ // Make the BYTE array, factor of 3 because it's RBG.
+ static GLubyte* pixels;
+ pixels = new GLubyte[ 3 * SCREEN_WIDTH * SCREEN_HEIGHT];
+ glReadPixels(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, GL_RGB, GL_UNSIGNED_BYTE, pixels);
+ takeScreenshot(pixels);
+
+ std::cout << "Took screenshot" << std::endl;
+ break;
+ case SDLK_UP:
+ player->inv->setSelectionUp();
+ break;
+ case SDLK_DOWN:
+ player->inv->setSelectionDown();
+ break;
+ default:
+ break;
+ }
+
+ break;
+ default:
+ break;
+ }
+ }
+}
#include <ui_menu.hpp>
+#include <render.hpp>
+
#include <fstream>
extern bool gameRunning;
SDL_Event e;
- useShader(&textShader,
- &textShader_uniform_texture,
- &textShader_attribute_coord,
- &textShader_attribute_tex);
+ Render::useShader(&Render::textShader);
setFontSize(24);
game::config::update();
static GLuint backTex = Texture::genColor(Color(0, 0, 0, 204));
//static GLuint bsTex = Texture::genColor(Color(30, 30, 30));
- static GLuint border = Texture::genColor(Color(245, 245, 245));
+ static GLuint border = Texture::genColor(Color(245, 245, 245));
GLfloat line_tex[] = {0.0, 0.0,
1.0, 0.0,
//draw the dark transparent background
glColor4f(0.0f, 0.0f, 0.0f, .8f);
- glUseProgram(textShader);
-
+ Render::textShader.use();
+
glBindTexture(GL_TEXTURE_2D, backTex);
- drawRect(vec2(offset.x - SCREEN_WIDTH / 2 - 1, offset.y - (SCREEN_HEIGHT / 2)),
- vec2(offset.x + SCREEN_WIDTH / 2, offset.y + (SCREEN_HEIGHT / 2)), -8.5);
+ Render::drawRect(vec2(offset.x - SCREEN_WIDTH / 2 - 1, offset.y - (SCREEN_HEIGHT / 2)),
+ vec2(offset.x + SCREEN_WIDTH / 2, offset.y + (SCREEN_HEIGHT / 2)), -8.5);
- glUseProgram(0);
+ Render::textShader.unuse();
//loop through all elements of the menu
for (auto &m : currentMenu->items) {
//draw the button background
GLuint bsTex = Texture::genColor(Color(m.button.color.red,m.button.color.green,m.button.color.blue));
-
- glUseProgram(textShader);
+
+ Render::textShader.use();
glBindTexture(GL_TEXTURE_2D, bsTex);
- drawRect(vec2(offset.x + m.button.loc.x, offset.y + m.button.loc.y),
- vec2(offset.x + m.button.loc.x + m.button.dim.x, offset.y + m.button.loc.y + m.button.dim.y), -8.6);
+ Render::drawRect(vec2(offset.x + m.button.loc.x, offset.y + m.button.loc.y),
+ vec2(offset.x + m.button.loc.x + m.button.dim.x, offset.y + m.button.loc.y + m.button.dim.y), -8.6);
//draw the button text
putStringCentered(offset.x + m.button.loc.x + (m.button.dim.x/2),
(offset.y + m.button.loc.y + (m.button.dim.y/2)) - ui::fontSize/2,
//if the mouse if over the button, it draws this white outline
glBindTexture(GL_TEXTURE_2D, border);
-
+
GLfloat verts[] = {offset.x+m.button.loc.x, offset.y+m.button.loc.y, -8.7,
offset.x+m.button.loc.x+m.button.dim.x, offset.y+m.button.loc.y, -8.7,
offset.x+m.button.loc.x+m.button.dim.x, offset.y+m.button.loc.y+m.button.dim.y, -8.7,
offset.x+m.button.loc.x, offset.y+m.button.loc.y+m.button.dim.y, -8.7,
offset.x+m.button.loc.x, offset.y+m.button.loc.y, -8.7};
- glUseProgram(textShader);
- glEnableVertexAttribArray(textShader_attribute_coord);
- glEnableVertexAttribArray(textShader_attribute_tex);
+ Render::textShader.use();
+ Render::textShader.enable();
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, verts);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, line_tex);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, verts);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, line_tex);
glDrawArrays(GL_LINE_STRIP, 0, 5);
- glDisableVertexAttribArray(textShader_attribute_coord);
- glDisableVertexAttribArray(textShader_attribute_tex);
-
+ Render::textShader.disable();
+ Render::textShader.unuse();
+
//if the mouse is over the button and clicks
if (SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(SDL_BUTTON_LEFT)) {
switch(m.member) {
m.slider.sliderLoc = m.slider.minValue + (*m.slider.var/m.slider.maxValue)*(m.slider.dim.x-sliderW);
}
//draw the background of the slider
- glUseProgram(textShader);
+ Render::textShader.use();
GLuint bsTex = Texture::genColor(Color(m.slider.color.red, m.slider.color.green, m.slider.color.blue, 175));
- GLuint hTex = Texture::genColor(Color(m.slider.color.red, m.slider.color.green, m.slider.color.blue, 255));
+ GLuint hTex = Texture::genColor(Color(m.slider.color.red, m.slider.color.green, m.slider.color.blue, 255));
glBindTexture(GL_TEXTURE_2D, bsTex);
- drawRect(vec2(offset.x + m.slider.loc.x, offset.y + m.slider.loc.y),
- vec2(offset.x + m.slider.loc.x + m.slider.dim.x, offset.y + m.slider.loc.y + m.slider.dim.y), -8.6);
-
+ Render::drawRect(vec2(offset.x + m.slider.loc.x, offset.y + m.slider.loc.y),
+ vec2(offset.x + m.slider.loc.x + m.slider.dim.x, offset.y + m.slider.loc.y + m.slider.dim.y), -8.6);
+
//draw the slider handle
glBindTexture(GL_TEXTURE_2D, hTex);
if (m.slider.dim.y > m.slider.dim.x) {
- drawRect(vec2(offset.x+m.slider.loc.x, offset.y+m.slider.loc.y + (m.slider.sliderLoc * 1.05)),
- vec2(offset.x+m.slider.loc.x + sliderW, offset.y+m.slider.loc.y + (m.slider.sliderLoc * 1.05) + sliderH), -8.7);
+ Render::drawRect(vec2(offset.x+m.slider.loc.x, offset.y+m.slider.loc.y + (m.slider.sliderLoc * 1.05)),
+ vec2(offset.x+m.slider.loc.x + sliderW, offset.y+m.slider.loc.y + (m.slider.sliderLoc * 1.05) + sliderH), -8.7);
//draw the now combined slider text
putStringCentered(offset.x + m.slider.loc.x + (m.slider.dim.x/2), (offset.y + m.slider.loc.y + (m.slider.dim.y*1.05)) - ui::fontSize/2, outSV);
}else{
- drawRect(vec2(offset.x+m.slider.loc.x+m.slider.sliderLoc, offset.y+m.slider.loc.y),
- vec2(offset.x+m.slider.loc.x + m.slider.sliderLoc + sliderW, offset.y+m.slider.loc.y + sliderH), -8.7);
+ Render::drawRect(vec2(offset.x+m.slider.loc.x+m.slider.sliderLoc, offset.y+m.slider.loc.y),
+ vec2(offset.x+m.slider.loc.x + m.slider.sliderLoc + sliderW, offset.y+m.slider.loc.y + sliderH), -8.7);
//draw the now combined slider text
putStringCentered(offset.x + m.slider.loc.x + (m.slider.dim.x/2), (offset.y + m.slider.loc.y + (m.slider.dim.y/2)) - ui::fontSize/2, outSV);
//if it is we draw a white border around it
glBindTexture(GL_TEXTURE_2D, border);
- glUseProgram(textShader);
- glEnableVertexAttribArray(textShader_attribute_coord);
- glEnableVertexAttribArray(textShader_attribute_tex);
-
+ Render::textShader.use();
+ Render::textShader.enable();
+
GLfloat box_border[] = {offset.x+m.slider.loc.x, offset.y+m.slider.loc.y, -8.8,
offset.x+m.slider.loc.x+m.slider.dim.x, offset.y+m.slider.loc.y, -8.8,
offset.x+m.slider.loc.x+m.slider.dim.x, offset.y+m.slider.loc.y+m.slider.dim.y, -8.8,
offset.x+m.slider.loc.x, offset.y+m.slider.loc.y+m.slider.dim.y, -8.8,
offset.x+m.slider.loc.x, offset.y+m.slider.loc.y, -8.8};
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, box_border);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, line_tex);
- glDrawArrays(GL_LINE_STRIP, 0, 5);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, box_border);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, line_tex);
+ glDrawArrays(GL_LINE_STRIP, 0, 5);
if (m.slider.dim.y > m.slider.dim.x) {
//and a border around the slider handle
GLfloat handle_border[] = {offset.x+m.slider.loc.x, static_cast<GLfloat>(offset.y+m.slider.loc.y + (m.slider.sliderLoc * 1.05)), -8.8,
offset.x+m.slider.loc.x + sliderW, static_cast<GLfloat>(offset.y+m.slider.loc.y + (m.slider.sliderLoc * 1.05) + sliderH), -8.8,
offset.x+m.slider.loc.x, static_cast<GLfloat>(offset.y+m.slider.loc.y + (m.slider.sliderLoc * 1.05) + sliderH), -8.8,
offset.x+m.slider.loc.x, static_cast<GLfloat>(offset.y+m.slider.loc.y + (m.slider.sliderLoc * 1.05)), -8.8};
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, handle_border);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, line_tex);
- glDrawArrays(GL_LINE_STRIP, 0, 5);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, handle_border);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, line_tex);
+ glDrawArrays(GL_LINE_STRIP, 0, 5);
}else{
//and a border around the slider handle
GLfloat handle_border[] = {offset.x+m.slider.loc.x + m.slider.sliderLoc, offset.y+m.slider.loc.y, -8.8,
offset.x+m.slider.loc.x + (m.slider.sliderLoc + sliderW), offset.y+m.slider.loc.y+m.slider.dim.y,-8.8,
offset.x+m.slider.loc.x + m.slider.sliderLoc, offset.y+m.slider.loc.y+m.slider.dim.y, -8.8,
offset.x+m.slider.loc.x + m.slider.sliderLoc, offset.y+m.slider.loc.y, -8.8};
- glVertexAttribPointer(textShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, handle_border);
- glVertexAttribPointer(textShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, line_tex);
- glDrawArrays(GL_LINE_STRIP, 0, 5);
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, handle_border);
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, line_tex);
+ glDrawArrays(GL_LINE_STRIP, 0, 5);
}
- glDisableVertexAttribArray(textShader_attribute_coord);
- glDisableVertexAttribArray(textShader_attribute_tex);
+ Render::textShader.disable();
//if we are inside the slider and click it will set the slider to that point
if (SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(SDL_BUTTON_LEFT)) {
*m.slider.var = (((mouse.y-offset.y) - m.slider.loc.y)/m.slider.dim.y)*100;
//draw a white box over the handle
glBindTexture(GL_TEXTURE_2D, border);
- drawRect(vec2(offset.x+m.slider.loc.x, offset.y+m.slider.loc.y + (m.slider.sliderLoc * 1.05)),
- vec2(offset.x+m.slider.loc.x + sliderW, offset.y+m.slider.loc.y + (m.slider.sliderLoc * 1.05) + sliderH), -8.9);
+ Render::drawRect(vec2(offset.x+m.slider.loc.x, offset.y+m.slider.loc.y + (m.slider.sliderLoc * 1.05)),
+ vec2(offset.x+m.slider.loc.x + sliderW, offset.y+m.slider.loc.y + (m.slider.sliderLoc * 1.05) + sliderH), -8.9);
}else{
*m.slider.var = (((mouse.x-offset.x) - m.slider.loc.x)/m.slider.dim.x)*100;
//draw a white box over the handle
glBindTexture(GL_TEXTURE_2D, border);
- drawRect(vec2(offset.x+m.slider.loc.x + m.slider.sliderLoc, offset.y+m.slider.loc.y),
- vec2(offset.x+m.slider.loc.x + (m.slider.sliderLoc + sliderW), offset.y+m.slider.loc.y + m.slider.dim.y), -8.9);
+ Render::drawRect(vec2(offset.x+m.slider.loc.x + m.slider.sliderLoc, offset.y+m.slider.loc.y),
+ vec2(offset.x+m.slider.loc.x + (m.slider.sliderLoc + sliderW), offset.y+m.slider.loc.y + m.slider.dim.y), -8.9);
}
}
--- /dev/null
+#include <window.hpp>
+
+#include <config.hpp>
+
+#include <SDL2/SDL_image.h>
+#include <SDL2/SDL_mixer.h>
+
+constexpr const char* WINDOW_TITLE = "gamedev";
+
+WindowSystem::WindowSystem(void)
+{
+ // attempt to initialize SDL
+ if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) != 0) {
+ std::cout << "SDL was not able to initialize! Error: " << SDL_GetError();
+ abort();
+ }
+ atexit(SDL_Quit);
+
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
+ SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
+
+ // attempt to initialize SDL_image
+ if (!(IMG_Init(IMG_INIT_PNG | IMG_INIT_JPG) & (IMG_INIT_PNG | IMG_INIT_JPG))) {
+ std::cout << "Could not init image libraries! Error: " << IMG_GetError();
+ abort();
+ }
+ atexit(IMG_Quit);
+
+ // attempt to initialize SDL_mixer
+ if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048) < 0) {
+ std::cout << "SDL_mixer could not initialize! Error: " << Mix_GetError();
+ abort();
+ }
+ Mix_AllocateChannels(8);
+ atexit(Mix_Quit);
+
+ // create the SDL window object
+ window = SDL_CreateWindow(WINDOW_TITLE,
+ SDL_WINDOWPOS_UNDEFINED, // Spawn the window at random (undefined) x and y coordinates
+ SDL_WINDOWPOS_UNDEFINED, //
+ game::SCREEN_WIDTH,
+ game::SCREEN_HEIGHT,
+ SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL
+ );
+
+ if (window == nullptr) {
+ std::cout << "The window failed to generate! SDL_Error: " << SDL_GetError();
+ abort();
+ }
+
+ // create the OpenGL object that SDL provides
+ if ((glContext = SDL_GL_CreateContext(window)) == nullptr) {
+ std::cout << "The OpenGL context failed to initialize! SDL_Error: " << SDL_GetError();
+ abort();
+ }
+}
+
+WindowSystem::~WindowSystem(void)
+{
+ SDL_GL_DeleteContext(glContext);
+ SDL_DestroyWindow(window);
+}
+
+void WindowSystem::update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt)
+{
+ (void)en;
+ (void)ev;
+ (void)dt;
+
+ SDL_GL_SwapWindow(window);
+}
#include <ui.hpp>
#include <gametime.hpp>
+#include <render.hpp>
+
// local library headers
#include <tinyxml2.h>
using namespace tinyxml2;
unsigned size, void *coordAddr, void *texAddr, unsigned triCount
)
{
- glVertexAttribPointer(worldShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, size, coordAddr);
- glVertexAttribPointer(worldShader_attribute_tex , 2, GL_FLOAT, GL_FALSE, size, texAddr );
+ glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, size, coordAddr);
+ glVertexAttribPointer(Render::worldShader.tex , 2, GL_FLOAT, GL_FALSE, size, texAddr );
glDrawArrays(GL_TRIANGLES, 0, triCount);
}
unsigned size, void *coordAddr, void *texAddr, unsigned triCount
)
{
- glEnableVertexAttribArray(worldShader_attribute_coord);
- glEnableVertexAttribArray(worldShader_attribute_tex);
+ Render::worldShader.enable();
makeWorldDrawingSimplerEvenThoughAndyDoesntThinkWeCanMakeItIntoFunctions(size, coordAddr, texAddr, triCount);
- glDisableVertexAttribArray(worldShader_attribute_tex);
- glDisableVertexAttribArray(worldShader_attribute_coord);
+ Render::worldShader.disable();
}
/* ----------------------------------------------------------------------------
}
glActiveTexture(GL_TEXTURE0);
- glUniform1i(worldShader_uniform_texture, 0);
+ glUniform1i(Render::worldShader.uniform[WU_texture], 0);
// draw background images.
GLfloat tex_coord[] = { 0.0f, 1.0f,
offset.x - backgroundOffset.x - 5, offset.y - backgroundOffset.y, 9.8f,
offset.x - backgroundOffset.x - 5, offset.y + backgroundOffset.y, 9.8f};
- glUseProgram(worldShader);
- glUniform1f(worldShader_uniform_light_impact, 0.0f);
- glUniform4f(worldShader_uniform_ambient, 1.0, 1.0, 1.0, 1.0);
+ Render::worldShader.use();
+ glUniform1f(Render::worldShader.uniform[WU_light_impact], 0.0f);
+ glUniform4f(Render::worldShader.uniform[WU_ambient], 1.0, 1.0, 1.0, 1.0);
- glEnableVertexAttribArray(worldShader_attribute_coord);
- glEnableVertexAttribArray(worldShader_attribute_tex);
+ Render::worldShader.enable();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
bgTex(0);
- glUniform4f(worldShader_uniform_color, 1.0, 1.0, 1.0, 1.0);
+ glUniform4f(Render::worldShader.uniform[WU_tex_color], 1.0, 1.0, 1.0, 1.0);
makeWorldDrawingSimplerEvenThoughAndyDoesntThinkWeCanMakeItIntoFunctions(0, back_tex_coord, scrolling_tex_coord, 6);
bgTex++;
- glUniform4f(worldShader_uniform_color, 1.0, 1.0, 1.0, 1.3 - static_cast<float>(alpha)/255.0f);
+ glUniform4f(Render::worldShader.uniform[WU_tex_color], 1.0, 1.0, 1.0, 1.3 - static_cast<float>(alpha)/255.0f);
makeWorldDrawingSimplerEvenThoughAndyDoesntThinkWeCanMakeItIntoFunctions(0, fron_tex_coord, tex_coord, 6);
}
glBindTexture(GL_TEXTURE_2D, starTex);
//glUniform4f(worldShader_uniform_color, 1.0, 1.0, 1.0, (255.0f - (randGet() % 200 - 100)) / 255.0f);
- glUniform4f(worldShader_uniform_color, 1.0, 1.0, 1.0, 1.3 - static_cast<float>(alpha)/255.0f);
+ glUniform4f(Render::worldShader.uniform[WU_tex_color], 1.0, 1.0, 1.0, 1.3 - static_cast<float>(alpha)/255.0f);
makeWorldDrawingSimplerEvenThoughAndyDoesntThinkWeCanMakeItIntoFunctions(5 * sizeof(GLfloat), &star_coord[0], &star_coord[3], star.size() * 6);
}
- glDisableVertexAttribArray(worldShader_attribute_coord);
- glDisableVertexAttribArray(worldShader_attribute_tex);
+ Render::worldShader.disable();
+
+ glUniform4f(Render::worldShader.uniform[WU_tex_color], 1.0, 1.0, 1.0, 1.0);
+ glUniform4f(Render::worldShader.uniform[WU_ambient], ambient.red, ambient.green, ambient.blue, 1.0);
- glUniform4f(worldShader_uniform_color, 1.0, 1.0, 1.0, 1.0);
- glUniform4f(worldShader_uniform_ambient, ambient.red, ambient.green, ambient.blue, 1.0);
- glUseProgram(0);
+ Render::worldShader.unuse();
std::vector<vec3> bg_items;
}
}
- glUseProgram(worldShader);
- glUniform1f(worldShader_uniform_light_impact, 0.01);
+ Render::worldShader.use();
+ glUniform1f(Render::worldShader.uniform[WU_light_impact], 0.01);
makeWorldDrawingSimplerEvenThoughAndyDoesntThinkWeCanMakeItIntoFunctions_JustDrawThis(0, &bg_i[0], &bg_tx[0], bg_items.size());
- glUseProgram(0);
+ Render::worldShader.unuse();
// draw the remaining layers
for (unsigned int i = 0; i < 4; i++) {
}
}
- glUseProgram(worldShader);
- glUniform1f(worldShader_uniform_light_impact, 0.075f + (0.2f*i));
+ Render::worldShader.use();
+ glUniform1f(Render::worldShader.uniform[WU_light_impact], 0.075f + (0.2f*i));
makeWorldDrawingSimplerEvenThoughAndyDoesntThinkWeCanMakeItIntoFunctions_JustDrawThis(0, &bg_i[0], &bg_tx[0], c.size());
- glUseProgram(0);
+ Render::worldShader.unuse();
}
}
lightColors[lcIndex++] = 1.0;
}
- glUseProgram(worldShader);
+ Render::worldShader.use();
- glUniform4fv(worldShader_uniform_light, ls, lightCoords);
- glUniform4fv(worldShader_uniform_light_color, ls, lightColors);
- glUniform1i(worldShader_uniform_light_amt, ls);
+ glUniform4fv(Render::worldShader.uniform[WU_light], ls, lightCoords);
+ glUniform4fv(Render::worldShader.uniform[WU_light_color], ls, lightColors);
+ glUniform1i(Render::worldShader.uniform[WU_light_size], ls);
- glUseProgram(0);
+ Render::worldShader.unuse();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
dirtt.push_back(v.first.y);
}
- glUseProgram(worldShader);
- glUniform1f(worldShader_uniform_light_impact, 0.45f);
+ Render::worldShader.use();
+ glUniform1f(Render::worldShader.uniform[WU_light_impact], 0.45f);
- glEnableVertexAttribArray(worldShader_attribute_coord);
- glEnableVertexAttribArray(worldShader_attribute_tex);
+ Render::worldShader.enable();
- glVertexAttribPointer(worldShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, &dirtc[0]);
- glVertexAttribPointer(worldShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, &dirtt[0]);
+ glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 0, &dirtc[0]);
+ glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 0, &dirtt[0]);
glDrawArrays(GL_TRIANGLES, 0 , c.size());
- glDisableVertexAttribArray(worldShader_attribute_tex);
- glDisableVertexAttribArray(worldShader_attribute_coord);
-
- glUseProgram(0);
-
+ Render::worldShader.disable();
+ Render::worldShader.unuse();
//glEnd();
grasst.push_back(v.first.y);
}
- glUseProgram(worldShader);
- glUniform1f(worldShader_uniform_light_impact, 1.0f);
+ Render::worldShader.use();
+ glUniform1f(Render::worldShader.uniform[WU_light_impact], 1.0f);
- glEnableVertexAttribArray(worldShader_attribute_coord);
- glEnableVertexAttribArray(worldShader_attribute_tex);
+ Render::worldShader.enable();
- glVertexAttribPointer(worldShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 0, &grassc[0]);
- glVertexAttribPointer(worldShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 0, &grasst[0]);
+ glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 0, &grassc[0]);
+ glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 0, &grasst[0]);
glDrawArrays(GL_TRIANGLES, 0 , c.size());
- glDisableVertexAttribArray(worldShader_attribute_tex);
- glDisableVertexAttribArray(worldShader_attribute_coord);
-
- glUseProgram(0);
-
-
- //glUseProgram(0);
- //glDisable(GL_TEXTURE_2D);
-
- // draw particles
-
- glBindTexture(GL_TEXTURE_2D, colorIndex);
- glUniform1i(worldShader_uniform_texture, 0);
- glUseProgram(worldShader);
-
- glEnableVertexAttribArray(worldShader_attribute_coord);
- glEnableVertexAttribArray(worldShader_attribute_tex);
-
- /*GLfloat *pIndexT = &partVec[0];
- for (auto &p : particles) {
- if (!p.behind)
- p.draw(pIndexT);
- }
- glVertexAttribPointer(worldShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), &partVec[0]);
- glVertexAttribPointer(worldShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), &partVec[3]);
- glDrawArrays(GL_TRIANGLES, 0, ps * 6);
-*/
- glDisableVertexAttribArray(worldShader_attribute_tex);
- glDisableVertexAttribArray(worldShader_attribute_coord);
-
- glUseProgram(0);
+ Render::worldShader.disable();
+ Render::worldShader.unuse();
for (auto &e :entity)
e->draw();
-
+
// flatten grass under the player if the player is on the ground
if (p->ground) {
pOffset = (p->loc.x + p->width / 2 - worldStart) / HLINE;
// draw particles like a MASTAH
glBindTexture(GL_TEXTURE_2D, colorIndex);
- glUniform1i(worldShader_uniform_texture, 0);
- glUseProgram(worldShader);
+ glUniform1i(Render::worldShader.uniform[WU_texture], 0);
+ Render::worldShader.use();
- glUniform4f(worldShader_uniform_color, 1.0, 1.0, 1.0, .8);
+ glUniform4f(Render::worldShader.uniform[WU_tex_color], 1.0, 1.0, 1.0, .8);
- glEnableVertexAttribArray(worldShader_attribute_coord);
- glEnableVertexAttribArray(worldShader_attribute_tex);
+ Render::worldShader.enable();
partMutex.lock();
uint ps = particles.size();
}
partMutex.unlock();
- glVertexAttribPointer(worldShader_attribute_coord, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), &partVec[0]);
- glVertexAttribPointer(worldShader_attribute_tex, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), &partVec[3]);
+ glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), &partVec[0]);
+ glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), &partVec[3]);
glDrawArrays(GL_TRIANGLES, 0, ps * 6);
- glDisableVertexAttribArray(worldShader_attribute_tex);
- glDisableVertexAttribArray(worldShader_attribute_coord);
+ Render::worldShader.disable();
- glUniform4f(worldShader_uniform_color, 1.0, 1.0, 1.0, 1.0);
+ glUniform4f(Render::worldShader.uniform[WU_tex_color], 1.0, 1.0, 1.0, 1.0);
- glUseProgram(0);
+ Render::worldShader.unuse();
}
/**
addMerchant(float x, float y, bool housed)
{
Merchant *tmp = new Merchant();
-
+
tmp->spawn(x, y);
if (housed) {
}
*/
- glUseProgram(worldShader);
+ Render::worldShader.use();
glActiveTexture(GL_TEXTURE0);
bgTex(0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); //for the s direction
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); //for the t direction
- glUniform1i(worldShader_uniform_texture, 0);
- glUniform4f(worldShader_uniform_color, 1.0, 1.0, 1.0, 1.0);
+ glUniform1i(Render::worldShader.uniform[WU_texture], 0);
+ glUniform4f(Render::worldShader.uniform[WU_tex_color], 1.0, 1.0, 1.0, 1.0);
GLfloat backTile[] = {worldStart - SCREEN_WIDTH / 2, 0, 9.9,
-worldStart + SCREEN_WIDTH / 2, 0, 9.9,
}
}
- glUseProgram(worldShader);
-
+ Render::worldShader.use();
makeWorldDrawingSimplerEvenThoughAndyDoesntThinkWeCanMakeItIntoFunctions_JustDrawThis(0, &fc[0], &ft[0], floor.size() * 6);
-
- glUseProgram(0);
+ Render::worldShader.unuse();
/*
* Draw all entities.
<generation type="Random" width="1600"/>
<time>6000</time>
<spawnx>-300</spawnx>
- <npc name="Sanc" hasDialog="true" health="1" x="507.65619" y="67.099007" dindex="0"/>
- <npc name="Bob" hasDialog="true" spawnx="30" health="1" x="-146.74963" y="61.999046" dindex="0"/>
+ <npc name="Sanc" hasDialog="true" health="1" x="406.31683" y="72.998955" dindex="9999"/>
+ <npc name="Bob" hasDialog="true" spawnx="30" health="1" x="403.52261" y="72.998955" dindex="0"/>
<structure type="1" spawnx="300" alive="1"/>
<structure inside="bobshouse.xml" type="1" spawnx="10" alive="1"/>
<chest alive="1"/>
projects / clyne / gamedev.git / commitdiff