repo_name stringlengths 5 122 | path stringlengths 3 232 | text stringlengths 6 1.05M |
|---|---|---|
mamoniem/bellz | Source/Bellz/Gladiator.h | // All rights reserved, <NAME> 2016 http://www.mamoniem.com/
#pragma once
#include "GameDataTables.h"
#include "GameFramework/Character.h"
#include "Gladiator.generated.h"
UCLASS(config = Game)
class AGladiator : public ACharacter
{
GENERATED_BODY()
virtual void BeginPlay() override;
//Camera boom positioning th... |
mamoniem/bellz | Source/Bellz/BellzSaveGame.h | // All rights reserved, <NAME> 2016 http:
#pragma once
#include "GameFramework/SaveGame.h"
#include "BellzSaveGame.generated.h"
/**
*
*/
UCLASS()
class BELLZ_API UBellzSaveGame : public USaveGame
{
GENERATED_BODY()
public:
UPROPERTY(VisibleAnywhere, Category = SavedValues)
FString SlotName;
UPROPERTY(Visi... |
brandondixon/uart-message | umsg.c | //*****************************************************************************
//
// umsg.c - Driver for the UMSG module.
//
// Copyright (c) 2015 Sevun Scientific, Inc.. All rights reserved.
// Software License Agreement
//
// Redistribution and use in source and binary forms, with or without
// modification, a... |
Omicrxn/U.N.Squadron | PowerupOrange.h | <reponame>Omicrxn/U.N.Squadron<gh_stars>1-10
#ifndef __POWERUPORANGE_H__
#define __POWERUPORANGE_H__
#include "Weapon.h"
#include "Path.h"
class PowerupOrange : public Weapon
{
public:
// Constructor (x y coordinates in the world)
// Creates animation and movement data and the collider
PowerupOrange(int x, int y);... |
Omicrxn/U.N.Squadron | StealthBomber.h | <filename>StealthBomber.h<gh_stars>1-10
#pragma once
#ifndef _STEALTHBOMBER_H__
#define _STEALTHBOMBER_H__
#include "Enemy.h"
#include "Path.h"
enum SBState {
SPAWNING, IDLE,SHOOTING
};
class StealthBomber : public Enemy
{
public:
StealthBomber(int x, int y, bool spawnRight);
void Update() override;
void OnCollisio... |
Omicrxn/U.N.Squadron | Globals.h | <filename>Globals.h
#pragma once
#ifndef __GLOBALS_H__
#define __GLOBALS_H__
#include <windows.h>
#define LOG(format, ...) Log(__FILE__,__LINE__,format,__VA_ARGS__);
void Log(const char file[], int line, const char* format, ...);
#define EXIT_FAILURE 1
#define EXIT_SUCCESS 0
#define MIN( a, b ) ( ((a) < (b)) ? (a) :... |
Omicrxn/U.N.Squadron | GreenFighterPlane.h | <reponame>Omicrxn/U.N.Squadron
#pragma once
#include "Enemy.h"
#include "Path.h"
enum GFState {
gSPAWNING, gIDLE
};
class GreenFighterPlane : public Enemy
{
public:
// Constructor (x y coordinates in the world)
// Creates animation and movement data and the collider
GreenFighterPlane(int x, int y, bool spawnRight)... |
Omicrxn/U.N.Squadron | ModulePlayer.h | <gh_stars>1-10
#pragma once
#ifndef __MODULEPLAYER_H__
#define __MODULEPLAYER_H__
#include "Module.h"
#include "p2Point.h"
#include "SDL_rect.h"
#include "Animation.h"
struct SDL_Texture;
class ModulePlayer : public Module {
public:
ModulePlayer(bool startEnabled);
~ModulePlayer();
bool Start();
bool Init();
up... |
Omicrxn/U.N.Squadron | ModuleTextureManager.h | <reponame>Omicrxn/U.N.Squadron
#pragma once
#ifndef __ModuleTextures_H__
#define __ModuleTextures_H__
#include "Module.h"
#include "Globals.h"
#define MAX_TEXTURES 200
struct SDL_Texture;
class ModuleTextureManager : public Module
{
public:
ModuleTextureManager(bool startEnabled);
~ModuleTextureManager();
bool I... |
Omicrxn/U.N.Squadron | ModuleStartScreen.h | #pragma once
#ifndef __MODULESTARTSCREEN_H__
#define __MODULESTARTSCREEN_H__
#include "Module.h"
#include "Animation.h"
#include "p2Point.h"
struct SDL_Texture;
class ModuleStartScreen : public Module
{
public:
ModuleStartScreen(bool startEnabled);
~ModuleStartScreen();
bool Start();
update_status Update();
upd... |
Omicrxn/U.N.Squadron | SB_BombShrapnel.h | #pragma once
#ifndef __SB_BOMBSHRAPNEL_H__
#define __SB_BOMBSHRAPNEL_H__
#include "Weapon.h"
#include "Path.h"
class SB_BombShrapnel : public Weapon
{
public:
// Constructor (x y coordinates in the world)
// Creates animation and movement data and the collider
SB_BombShrapnel(int x, int y,unsigned int number);
/... |
Omicrxn/U.N.Squadron | PowerupBlue.h | <gh_stars>1-10
#ifndef __POWERUPBLUE_H__
#define __POWERUPBLUE_H__
#include "Weapon.h"
#include "Path.h"
class PowerupBlue : public Weapon
{
public:
// Constructor (x y coordinates in the world)
// Creates animation and movement data and the collider
PowerupBlue(int x, int y);
void Update() override;
void OnCo... |
Omicrxn/U.N.Squadron | Application.h | <reponame>Omicrxn/U.N.Squadron
#pragma once
#ifndef __APPLICATION_H__
#define __APPLICATION_H__
#include "Globals.h"
class Module;
class ModuleWindow;
class ModuleInput;
class ModuleTextureManager;
class ModuleWinScreen;
class ModuleAudio;
class ModulePlayer;
class ModuleLevel1;
class ModuleLevel2;
class ModulePartic... |
Omicrxn/U.N.Squadron | ModuleSelector.h | #pragma once
#ifndef __MODULESELECTOR_H__
#define __MODULESELECTOR_H__
#include "Module.h"
#include "Globals.h"
#include "Animation.h"
#include "p2Point.h"
enum selection {
LEVEL1, LEVEL2
};
struct SDL_Texture;
class ModuleSelector : public Module
{
public:
ModuleSelector(bool startEnabled);
~ModuleSelector();
... |
Omicrxn/U.N.Squadron | ModuleWindow.h | #pragma once
#ifndef __ModuleWindow_H__
#define __ModuleWindow_H__
#include "Module.h"
struct SDL_Window;
struct SDL_Surface;
class ModuleWindow : public Module
{
public:
ModuleWindow(bool startEnabled);
virtual ~ModuleWindow();
bool Init();
bool CleanUp();
SDL_Window* sdlWindow = nullptr;
SDL_Surface* sc... |
Omicrxn/U.N.Squadron | ModuleLevel1.h | #pragma once
#ifndef __MODULELEVEL1_H__
#define __MODULELEVEL1_H__
#include "Module.h"
#include "Globals.h"
#include "SDL_rect.h"
#include "p2Point.h"
struct SDL_Texture;
class ModuleLevel1 : public Module
{
public:
ModuleLevel1(bool startEnabled);
~ModuleLevel1();
bool Start();
update_status Update();
update... |
Omicrxn/U.N.Squadron | ModuleLoseScreen.h | <gh_stars>1-10
#pragma once
#include "Module.h"
#include "Globals.h"
#include "SDL_timer.h"
#include "SDL_rect.h"
#include "Animation.h"
struct SDL_Texture;
class ModuleLoseScreen : public Module
{
public:
ModuleLoseScreen(bool startEnabled);
~ModuleLoseScreen();
bool Start();
update_status Update();
update_stat... |
Omicrxn/U.N.Squadron | Weapon.h | <gh_stars>1-10
#ifndef __WEAPON_H__
#define __WEAPON_H__
#include "p2Point.h"
#include "Animation.h"
struct SDL_Texture;
struct Collider;
class Weapon
{
public:
// Constructor
// Saves the spawn position for later movement calculations
Weapon(int x, int y);
// Destructor
virtual ~Weapon();
// Returns the wea... |
Omicrxn/U.N.Squadron | ModuleInput.h | #pragma once
#ifndef __ModuleInput_H__
#define __ModuleInput_H__
#include "Module.h"
#include "Globals.h"
#include "SDL_scancode.h"
#include "SDL.h"
#define MAX_KEYS 300
#define MAX_PADS 4
struct _SDL_GameController;
struct _SDL_Haptic;
enum key_state {
KEY_IDLE = 0,
KEY_DOWN,
KEY_REPEAT,
KEY_UP
};
struct Game... |
Omicrxn/U.N.Squadron | ModuleStore.h | #pragma once
#ifndef __MODULESTORE_H__
#define __MODULESTORE_H__
#include "Module.h"
#include "Animation.h"
#include "p2Point.h"
struct SDL_Texture;
class ModuleStore : public Module
{
public:
ModuleStore(bool startEnabled);
~ModuleStore();
bool Start();
update_status Update();
update_status PostUpdate();
bool... |
Omicrxn/U.N.Squadron | ModuleInitialScreen.h | #pragma once
#ifndef __MODULEINITIALSCREEN_H__
#define __MODULEINITIALSCREEN_H__
#include "Module.h"
#include "Globals.h"
#include "SDL_timer.h"
#include "SDL_rect.h"
struct SDL_Texture;
class ModuleInitialScreen : public Module
{
public:
ModuleInitialScreen(bool startEnabled);
~ModuleInitialScreen();
bool Start(... |
Omicrxn/U.N.Squadron | Module.h | #pragma once
#ifndef __MODULE_H__
#define __MODULE_H__
#include "Globals.h"
struct Collider;
class Module
{
private:
bool enabled = true;
public:
Module(bool startEnabled);
//Called at the beginning of the application execution
virtual bool Init();
//Called when the module is activated
virtual bool Start();
... |
Omicrxn/U.N.Squadron | Bomb.h | <gh_stars>1-10
#ifndef __BOMB_H__
#define __BOMB_H__
#include "Weapon.h"
#include "Path.h"
class Bomb : public Weapon
{
public:
// Constructor (x y coordinates in the world)
// Creates animation and movement data and the collider
Bomb(int x, int y);
// The weapon is going to follow the different steps in the pat... |
Omicrxn/U.N.Squadron | p2Point.h | #pragma once
#ifndef __PointOperations_h__
#define __PointOperations_h__
#include "Globals.h"
#include <math.h>
template<class TYPE>
class PointOperations
{
public:
TYPE x, y;
PointOperations()
{}
PointOperations(const PointOperations& v)
{
this->x = v.x;
this->y = v.y;
}
PointOperations(const TYPE& x... |
Omicrxn/U.N.Squadron | SB_Bomb.h | <reponame>Omicrxn/U.N.Squadron<gh_stars>1-10
#pragma once
#ifndef __SB_BOMB_H__
#define __SB_BOMB_H__
#include "Weapon.h"
#include "Path.h"
class SB_Bomb : public Weapon
{
public:
// Constructor (x y coordinates in the world)
// Creates animation and movement data and the collider
SB_Bomb(int x, int y,unsigned int... |
Omicrxn/U.N.Squadron | ModuleLevel2.h | <reponame>Omicrxn/U.N.Squadron<gh_stars>1-10
#pragma once
#ifndef __MODULELEVEL2_H__
#define __MODULELEVEL2_H__
#include "Module.h"
#include "Globals.h"
#include "SDL_rect.h"
#include "p2Point.h"
struct SDL_Texture;
class ModuleLevel2 : public Module
{
public:
ModuleLevel2(bool startEnabled);
~ModuleLevel2();
bo... |
Omicrxn/U.N.Squadron | ModuleWeapons.h | <gh_stars>1-10
#ifndef __MODULE_WEAPONS_H__
#define __MODULE_WEAPONS_H__
#include "Module.h"
#define MAX_WEAPONS 100
// Create new weapon types:
enum class WEAPON_TYPE
{
NO_TYPE, BOMB, SHELL, FALCON, CEILING, GF_HOOK, SB_BOMB, SB_SHRAPNEL, POWERUP_BLUE, POWERUP_ORANGE, LEVEL1GUN
};
struct WeaponSpawnpoint
{
WEAPO... |
Omicrxn/U.N.Squadron | ModuleWinScreen.h | <filename>ModuleWinScreen.h
#pragma once
#ifndef __MODULEWINSCREEN_H__
#define __MODULEWINSCREEN_H__
#include "Module.h"
#include "Globals.h"
#include "SDL_timer.h"
#include "SDL_rect.h"
struct SDL_Texture;
class ModuleWinScreen : public Module
{
public:
ModuleWinScreen(bool startEnabled);
~ModuleWinScreen();
boo... |
Omicrxn/U.N.Squadron | ModuleParticles.h | #pragma once
#ifndef __MODULEPARTICLES_H__
#define __MODULEPARTICLES_H__
#include "Application.h"
#include "Animation.h"
#include "p2Point.h"
#include "Module.h"
#include "SDL.h"
#include "ModuleCollisions.h"
#define MAX_ACTIVE_PARTICLES 200
struct SDL_Texture;
struct Collider;
struct Particle
{
public:
// Constr... |
Omicrxn/U.N.Squadron | SetBulletDirection.h | <filename>SetBulletDirection.h
#include "Enemy.h"
void SetBulletDirection(Enemy* enemy); |
Omicrxn/U.N.Squadron | ModuleRenderer.h | #pragma once
#ifndef __ModuleRenderer_H__
#define __ModuleRenderer_H__
#include "Module.h"
#include "SDL_rect.h"
struct SDL_Texture;
struct SDL_Renderer;
class ModuleRenderer : public Module
{
public:
ModuleRenderer(bool startEnabled);
~ModuleRenderer();
bool Init();
update_status PreUpdate();
update_status ... |
naudhizb/NumOperation | NumOperation.h | <gh_stars>0
/**
* @file NumOperation.h
* @author naudhizb (<EMAIL>)
* @brief
* @version 0.1
* @date 2021-01-27
*
* @copyright Copyright (c) 2021
*
*/
#ifndef NUMOPERATION_H_
#define NUMOPERATION_H_
#if __cplusplus
extern "C" {
#endif
#include <stdint.h>
#define NumOp_Saturate(data, min, max) ((data) < ... |
naudhizb/NumOperation | NumOperation.c | /**
* @file NumOperation.c
* @author naudhizb (<EMAIL>)
* @brief
* @version 0.1
* @date 2021-01-29
*
* @copyright Copyright (c) 2021
*
*/
#include "NumOperation.h"
#include <stdio.h>
float NumOp_GetPercentage(float data, float min, float max){
float percent = (data - min) / (max - min);
return pe... |
CMTFrostyy/GTA127_PS4505-Native_Caller | gtaPayload/include/invoker.h | #pragma once
#include "types.h"
#include <utility>
// struct Native_s {
// struct Native_s *lastNativeTable;
// u64 nativeFunctions[7];
// u64 nativeCount;
// u64 nativeHashes[7];
// };
struct NativeArg_s {
u64* returnValue;
u32 argCount;
u8 padding1[4];
u64* argValues;
u32 vectorCount;
u8 padding2[4];
Ve... |
CMTFrostyy/GTA127_PS4505-Native_Caller | source/main.c | #include "ps4.h"
#include "kern.h"
#include "proc.h"
#include "gta.h"
extern char gtaPayload[];
extern int gtaPayloadSize;
int gamePID;
void* hookAddress;
double(*ceil)(double x);
int(*sceSysUtilSendSystemNotificationWithText)(int messageType, char* message);
void sysNotify(char* msg) {
sceSysUtilSendSystemNotific... |
scveloso/Software | src/software/ai/intent/intent.h | #pragma once
#include <string>
#include <vector>
#include "software/ai/intent/avoid_area.h"
// We forward-declare the IntentVisitor interface (pure virtual class) because we need
// to know about the existence of this class in order to accept visitors with the
// accept() function. We cannot use an #include statemen... |
scveloso/Software | src/software/ai/world/robot_capabilities.h | #pragma once
#include <bitset>
#include <initializer_list>
#include <ostream>
class RobotCapabilityFlags
{
public:
typedef enum
{
Kick = 0,
Chip = 1,
Dribble = 2,
MAX = 3
} RobotCapability;
/**
* returns a RobotCapabilityFlags object with all of the ca... |
scveloso/Software | src/software/ai/hl/stp/tactic/crease_defender_tactic.h | <filename>src/software/ai/hl/stp/tactic/crease_defender_tactic.h
#pragma once
#include "software/ai/hl/stp/evaluation/enemy_threat.h"
#include "software/ai/hl/stp/tactic/tactic.h"
#include "software/geom/segment.h"
/**
* A crease defender moves around the exterior of our defense box to help shadow
* shots against t... |
scveloso/Software | src/software/util/time/timestamp.h | #pragma once
#include "software/util/time/duration.h"
#include "software/util/time/time.h"
/**
* A simple Timestamp class built around doubles. This Timestamp is intended to represent
* the t_capture timestamps we receive from the SSL Vision system. These t_capture values
* are monotonic (meaning they are always p... |
scveloso/Software | src/software/ai/intent/direct_wheels_intent.h | <reponame>scveloso/Software
#pragma once
#include "software/ai/intent/intent.h"
#include "software/ai/primitive/direct_wheels_primitive.h"
class DirectWheelsIntent : public Intent, public DirectWheelsPrimitive
{
public:
static const std::string INTENT_NAME;
/**
* Creates a new DirectWheels Intent
... |
scveloso/Software | src/software/ai/hl/hl.h | #pragma once
#include <memory>
#include <vector>
#include "software/ai/hl/stp/play_info.h"
#include "software/ai/intent/intent.h"
#include "software/ai/world/world.h"
/**
* An abstraction for the high-level logic of our AI. The high-level logic is responsible
* for the major strategic gameplay decisions of the AI.... |
scveloso/Software | src/software/ai/navigator/path_planning_navigator/obstacle/obstacle.h | /**
* An obstacle is an area to avoid based on the size of the robot and its velocity
*/
#pragma once
#include "shared/constants.h"
#include "software/ai/world/ball.h"
#include "software/ai/world/robot.h"
#include "software/geom/angle.h"
#include "software/geom/circle.h"
#include "software/geom/point.h"
#include "s... |
scveloso/Software | src/software/ai/hl/stp/play/corner_kick_play.h | <filename>src/software/ai/hl/stp/play/corner_kick_play.h
#pragma once
#include "software/ai/hl/stp/play/play.h"
#include "software/ai/hl/stp/tactic/cherry_pick_tactic.h"
#include "software/ai/hl/stp/tactic/move_tactic.h"
/**
* A Play for Corner Kicks
*/
class CornerKickPlay : public Play
{
public:
static con... |
scveloso/Software | src/software/ai/intent/pivot_intent.h | #pragma once
#include "software/ai/intent/intent.h"
#include "software/ai/primitive/pivot_primitive.h"
#include "software/geom/angle.h"
#include "software/geom/point.h"
class PivotIntent : public Intent, public PivotPrimitive
{
public:
static const std::string INTENT_NAME;
/**
* Creates a new Pivot In... |
scveloso/Software | src/software/ai/hl/stp/tactic/cherry_pick_tactic.h | /**
* Declaration for the CherryPickTactic class
*/
#pragma once
#include "software/ai/hl/stp/tactic/tactic.h"
#include "software/ai/passing/pass_generator.h"
#include "software/ai/world/world.h"
#include "software/geom/rectangle.h"
/**
* This tactic is intended to place a robot in a given region, and have the rob... |
scveloso/Software | src/software/backend/output/radio/radio_output.h | #pragma once
#include <limits>
#include "software/ai/world/ball.h"
#include "software/ai/world/team.h"
#include "software/backend/output/radio/mrf/dongle.h"
#include "software/backend/robot_status.h"
class RadioOutput
{
public:
/**
* Creates a new RadioOutput.
* Automatically connects to the dongle ... |
scveloso/Software | src/software/ai/navigator/path_planning_navigator/trespass.h | <reponame>scveloso/Software<filename>src/software/ai/navigator/path_planning_navigator/trespass.h
#pragma once
#include "software/geom/rectangle.h"
namespace Navigator
{
namespace Trespass
{
/**
* Returns a trespass score in the range [0, 1] for a rectangle
* If the point is outside ... |
scveloso/Software | src/software/backend/backend.h | #pragma once
#include "software/ai/primitive/primitive.h"
#include "software/ai/world/world.h"
#include "software/backend/robot_status.h"
#include "software/multithreading/subject.h"
#include "software/multithreading/threaded_observer.h"
#include "software/typedefs.h"
/**
* A Backend is an abstraction around all I/O... |
scveloso/Software | src/firmware/main/primitives/move.c | #include "move.h"
#include "control.h"
#include "physics.h"
#include "bangbang.h"
#include "util/physbot.h"
#include "shared_util/robot_constants.h"
#include "shared_util/constants.h"
#include "util/log.h"
#include "util/util.h"
#include <math.h>
#include <stdio.h>
#ifndef FWSIM
#include "chicker.h"
#include "dr.h"
#i... |
scveloso/Software | src/software/backend/output/grsim/grsim_output.h | <gh_stars>0
#pragma once
#include <boost/asio.hpp>
#include <string>
#include "software/ai/primitive/primitive.h"
#include "software/ai/world/ball.h"
#include "software/ai/world/team.h"
#include "software/geom/angle.h"
#include "software/geom/point.h"
#include "software/proto/grSim_Packet.pb.h"
class GrSimOutput
{
... |
scveloso/Software | src/software/ai/hl/stp/tactic/receiver_tactic.h | <reponame>scveloso/Software<filename>src/software/ai/hl/stp/tactic/receiver_tactic.h
/**
* Interface of the ReceiverTactic
*/
#pragma once
#include "software/ai/hl/stp/tactic/tactic.h"
#include "software/ai/passing/pass.h"
#include "software/geom/ray.h"
/**
* This tactic is for a robot receiving a pass. It should ... |
scveloso/Software | src/software/gui/visualizer_wrapper.h | <reponame>scveloso/Software<gh_stars>0
#pragma once
#include <QtCore/QGenericArgument>
#include <QtWidgets/QApplication>
#include <future>
#include <mutex>
#include <thread>
#include "software/ai/hl/stp/play_info.h"
#include "software/ai/world/world.h"
#include "software/backend/robot_status.h"
#include "software/gui... |
scveloso/Software | src/software/backend/output/radio/mrf/usb/device.h | #pragma once
#include <libusb/libusb.h>
#include <cstddef>
#include <cstdint>
#include <string>
#include "software/backend/output/radio/mrf/usb/devicehandle.h"
#include "software/backend/output/radio/mrf/util/noncopyable.h"
namespace USB
{
/* Forward declaration of the libusb context */
class Context;
c... |
scveloso/Software | src/software/ai/intent/avoid_area.h | <reponame>scveloso/Software<filename>src/software/ai/intent/avoid_area.h
#pragma once
#include <ostream>
/**
* This enum describes the areas that an intent can choose to avoid. They serve
* as an indicator to the navigator when it interprets the intents
*/
enum class AvoidArea
{
// The enemy robots and their a... |
scveloso/Software | src/software/gui/widgets/main_widget.h | #pragma once
#include <QtWidgets/QGraphicsScene>
#include <QtWidgets/QOpenGLWidget>
#include <QtWidgets/QTableWidget>
#include <QtWidgets/QWidget>
// This include is autogenerated by the .ui file in the same folder
// The generated version will be names 'ui_<filename>.h'
#include "software/ai/hl/stp/play_info.h"
#inc... |
scveloso/Software | src/software/ai/hl/stp/action/stop_action.h | #pragma once
#include "software/ai/hl/stp/action/action.h"
#include "software/geom/angle.h"
#include "software/geom/point.h"
/**
* The StopAction makes the robot stop with the option to coast
*/
class StopAction : public Action
{
public:
// We consider the robot to be stopped when the magnitude of its veloci... |
scveloso/Software | src/software/backend/output/radio/mrf/usb/devicehandle.h | <reponame>scveloso/Software<filename>src/software/backend/output/radio/mrf/usb/devicehandle.h
#pragma once
#include <libusb/libusb.h>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
#include "software/backend/output/radio/mrf/util/noncopyable.h"
namespa... |
scveloso/Software | src/software/ai/intent/stop_intent.h | #pragma once
#include "software/ai/intent/intent.h"
#include "software/ai/primitive/stop_primitive.h"
class StopIntent : public Intent, public StopPrimitive
{
public:
static const std::string INTENT_NAME;
/**
* Creates a new Stop Intent
*
* Stops the robot with the option to coast to a stop ... |
scveloso/Software | src/software/typedefs.h | #pragma once
/**
* We use this typedef to pass lists of Primitives around
*
* Since `std::unique_ptr<Primitive>` does not have a copy constructor, we
* need to pass a `shared_ptr` to the vector. To prevent people modifiying
* the vector we declare it `const`
*/
using ConstPrimitiveVectorPtr =
std::shared_ptr... |
scveloso/Software | src/firmware/freertos/source/port.c | <gh_stars>0
// Stack frame format, FPU not in use:
//
// Hardware:
// xPSR
// Return address
// LR
// R12
// R3
// R2
// R1
// R0
//
// Software:
// R11
// R10
// R9 ← Here and below may be covered by stack guard.
// R8
// R7
// R6
// R5
// R4
// Exception return code
// Stack guard RBAR
//
//
//
// Stack frame format,... |
scveloso/Software | src/software/backend/output/radio/mrf/usb/transfer.h | #pragma once
#include <libusb/libusb.h>
#include "software/backend/output/radio/mrf/usb/devicehandle.h"
#include "software/backend/output/radio/mrf/util/async_operation.h"
#include "software/backend/output/radio/mrf/util/noncopyable.h"
namespace USB
{
/* Forward declarations for C linkage */
extern "C" void ... |
scveloso/Software | src/software/test_util/test_util.h | #pragma once
#include "software/ai/world/ball.h"
#include "software/ai/world/field.h"
#include "software/ai/world/team.h"
#include "software/ai/world/world.h"
namespace Test
{
/**
* This util class is to provide utility functions to our unit test suite,
* primarily for assisting with test setup (such as... |
scveloso/Software | src/software/ai/hl/stp/action/move_action.h | #pragma once
#include "software/ai/hl/stp/action/action.h"
#include "software/ai/primitive/move_primitive.h"
#include "software/geom/angle.h"
#include "software/geom/point.h"
class MoveAction : public Action
{
public:
// We consider the robot close to a destination when it is within 2 cm.
// The robot shou... |
scveloso/Software | src/software/ai/navigator/path_planning_navigator/obstacle/robot_obstacle.h | #pragma once
#include "software/ai/world/world.h"
#include "software/geom/util.h"
#include "software/util/parameter/dynamic_parameters.h"
class RobotObstacle
{
public:
/**
* Constructor.
*
* @param robot Robot to create obstacle from.
* @param avoid_dist Distance to avoid obstacle by.
... |
scveloso/Software | src/software/ai/hl/stp/tactic/block_shot_path_tactic.h | <reponame>scveloso/Software<filename>src/software/ai/hl/stp/tactic/block_shot_path_tactic.h
#pragma once
#include "software/ai/hl/stp/tactic/tactic.h"
/**
* The BlockShotPathTactic will move the robot to block the entire friendly net from
* the shot
*/
class BlockShotPathTactic : public Tactic
{
public:
/**... |
scveloso/Software | src/software/ai/navigator/path_planning_navigator/path_planner/theta_star_path_planner.h | #pragma once
#include <bits/stdc++.h>
#include <unistd.h>
#include "software/ai/navigator/path_planning_navigator/path_planner/path_planner.h"
#include "software/ai/world/ball.h"
#include "software/ai/world/field.h"
/**
* ThetaStarPathPlanner uses the theta * algorithm to implement
* the PathPlanner interface.
* h... |
scveloso/Software | src/software/util/math/math_functions.h | <gh_stars>0
/*
* This file contains declarations for math functions
*/
#pragma once
#include "software/geom/circle.h"
#include "software/geom/point.h"
#include "software/geom/rectangle.h"
namespace Util
{
/**
* Linearly maps an input value to an output value in the range [0,1]
*
* @param value T... |
scveloso/Software | src/software/ai/navigator/placeholder_navigator/placeholder_navigator.h | <reponame>scveloso/Software
#pragma once
#include "software/ai/intent/intent.h"
#include "software/ai/intent/intent_visitor.h"
#include "software/ai/navigator/navigator.h"
#include "software/ai/primitive/primitive.h"
/**
* This PlaceholderNavigator is a simple navigator that will convert the given Intents
* into th... |
scveloso/Software | src/software/ai/hl/stp/evaluation/deflect_off_enemy_target.h | #pragma once
#include "software/ai/world/world.h"
namespace Evaluation
{
/* Returns the point at which the player should shoot to deflect the ball of an
* enemy
* to the outside of the field to get another kick/corner
*/
Point deflect_off_enemy_target(World world);
} // namespace Evaluation
|
alicin/GDDropZone | GDDropZone/GDDropZone.h | //
// GDDropZone.h
// GDDropZone
//
// Created by <NAME> on 27/05/2017.
// Copyright © 2017 Tavsanlar AS. All rights reserved.
//
#import <Cocoa/Cocoa.h>
//! Project version number for GDDropZone.
FOUNDATION_EXPORT double GDDropZoneVersionNumber;
//! Project version string for GDDropZone.
FOUNDATION_EXPORT const... |
Bytan97/CpSpec | YelBelt/week 6/result/database.h | <filename>YelBelt/week 6/result/database.h
#pragma once
#include "date.h"
#include <string>
#include <map>
#include <set>
#include <unordered_set>
#include <ostream>
#include <functional>
#include <vector>
#include <algorithm>
class Database {
public:
void Add(const Date &date, const std::string &event);
void P... |
Bytan97/CpSpec | YelBelt/week 3/decompose/bus_manager.h | <gh_stars>0
#pragma once
#include <vector>
#include <map>
#include "responses.h"
using namespace std;
class BusManager {
private:
map<string, vector<string>> buses_to_stops, stops_to_buses;
public:
void AddBus(const string &bus, const vector<string> &stops);
BusesForStopResponse GetBusesForStop(const string &st... |
Bytan97/CpSpec | YelBelt/week 3/decompose/query.h | <gh_stars>0
#pragma once
#include <string>
#include <vector>
#include <iostream>
using namespace std;
enum class QueryType {
NewBus,
BusesForStop,
StopsForBus,
AllBuses
};
struct Query {
QueryType type;
string bus;
string stop;
vector<string> stops;
};
//bool operator==(const Query &lhs, const Query &... |
Bytan97/CpSpec | YelBelt/week 6/result/node.h | #pragma once
#include "date.h"
#include <string>
#include <memory>
enum class LogicalOperation {
And,
Or
};
enum class Comparison {
Less,
LessOrEqual,
Greater,
GreaterOrEqual,
Equal,
NotEqual
};
class Node {
public:
// Node() = default;
virtual bool Evaluate(const Date &date, const std::string &e... |
Bytan97/CpSpec | YelBelt/week 6/result/date.h | <filename>YelBelt/week 6/result/date.h
#pragma once
#include <stdexcept>
#include <istream>
#include <iomanip>
#include <iostream>
#include <string>
#include <set>
#include <tuple>
class Date {
public:
Date(int n_year, int n_month, int n_day);
int GetYear() const;
int GetMonth() const;
int GetDay()... |
Bytan97/CpSpec | YelBelt/week 3/phone number/phone_number.h | #pragma once
#include <string>
#include <iostream>
#include <sstream>
using namespace std;
class PhoneNumber {
public:
explicit PhoneNumber(const string &international_number);
string GetCountryCode() const;
string GetCityCode() const;
string GetLocalNumber() const;
string GetInternationalNumber() const;... |
Bytan97/CpSpec | YelBelt/week 3/decompose/responses.h | <reponame>Bytan97/CpSpec
#pragma once
#include <string>
#include <vector>
#include <iostream>
#include <map>
using namespace std;
struct BusesForStopResponse {
string stop;
vector<string> buses;
};
ostream &operator<<(ostream &os, const BusesForStopResponse &r);
struct StopsForBusResponse {
string bus;
vect... |
UMM-CSci-3403-Fall-2017/lab-3-c-programming-arrays-doschicos | mergesort/mergesort.c | #include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include "mergesort.h"
void mergeRanges(int* values, int startIndex, int midPoint, int endIndex){
int rangeSize = endIndex - startIndex;
int* temp = (int*) calloc(rangeSize+1, sizeof(int));
int firstIndex = startIndex;
int seco... |
UMM-CSci-3403-Fall-2017/lab-3-c-programming-arrays-doschicos | array_merge/array_merge.c | <reponame>UMM-CSci-3403-Fall-2017/lab-3-c-programming-arrays-doschicos
#include "array_merge.h"
#include <stdlib.h>
#include "../mergesort/mergesort.c"
#include <stdio.h>
int* array_merge(int num_arrays, int* sizes, int** values) {
//Check to see if there are arrays in values
//If not then just return an empty ... |
diegomacario/Quaternion-Experiments | inc/model.h | #ifndef MODEL_H
#define MODEL_H
#include "shader.h"
#include "mesh.h"
#include "resource_manager.h"
class Model
{
public:
Model(std::vector<Mesh>&& meshes, ResourceManager<Texture>&& texManager);
Model(const Model&) = delete;
Model& operator=(const Model&) = delete;
Model(Model&& rhs) = default;
Mod... |
diegomacario/Quaternion-Experiments | inc/state.h | #ifndef STATE_H
#define STATE_H
class State
{
public:
State() = default;
virtual ~State() = default;
State(const State&) = delete;
State& operator=(const State&) = delete;
State(State&&) = delete;
State& operator=(State&&) = delete;
virtual void enter() = 0;
virtual void processInput(float ... |
diegomacario/Quaternion-Experiments | inc/texture_loader.h | <filename>inc/texture_loader.h
#ifndef TEXTURE_LOADER_H
#define TEXTURE_LOADER_H
#include <string>
#include <memory>
#include "texture.h"
class TextureLoader
{
public:
TextureLoader() = default;
~TextureLoader() = default;
TextureLoader(const TextureLoader&) = default;
TextureLoader& operator=(const Te... |
diegomacario/Quaternion-Experiments | inc/model_loader.h | <gh_stars>10-100
#ifndef MODEL_LOADER_H
#define MODEL_LOADER_H
#include <unordered_map>
#include "model.h"
#include "resource_manager.h"
class ModelLoader
{
public:
ModelLoader() = default;
~ModelLoader() = default;
ModelLoader(const ModelLoader&) = default;
ModelLoader& operator=(const ModelLoader&) =... |
diegomacario/Quaternion-Experiments | inc/camera.h | <filename>inc/camera.h
#ifndef CAMERA_H
#define CAMERA_H
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
class Camera
{
public:
Camera(glm::vec3 position,
glm::vec3 worldUp,
float yawInDeg,
float pitchInDeg,
float fieldOfViewYInDeg,
floa... |
diegomacario/Quaternion-Experiments | inc/line.h | <gh_stars>0
#ifndef LINE_H
#define LINE_H
#include <glm/glm.hpp>
#include "shader.h"
#include "quat.h"
class Line
{
public:
Line(glm::vec3 startPoint,
glm::vec3 endPoint,
const glm::vec3& position,
float angleOfRotInDeg,
const glm::vec3& axisOfRot,
... |
diegomacario/Quaternion-Experiments | inc/quat.h | <reponame>diegomacario/Quaternion-Experiments<gh_stars>0
#ifndef QUAT_H
#define QUAT_H
#include <glm/glm.hpp>
#define QUAT_EPSILON 0.000001f
struct quat {
union {
struct {
float x;
float y;
float z;
float w;
};
struct {
glm::vec3 vector;
float scalar;
};
float v[4];
};
inline quat() :... |
diegomacario/Quaternion-Experiments | inc/window.h | #ifndef WINDOW_H
#define WINDOW_H
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <bitset>
// TODO: Take advantage of inlining in this class.
class Window
{
public:
Window(const std::string& title);
~Window();
Window(const Window&) = delete;
Window& operator=(const Window&) = delete;
Window... |
diegomacario/Quaternion-Experiments | inc/texture.h | #ifndef TEXTURE_H
#define TEXTURE_H
#include <glad/glad.h>
class Texture
{
public:
explicit Texture(unsigned int texID);
~Texture();
Texture(const Texture&) = delete;
Texture& operator=(const Texture&) = delete;
Texture(Texture&& rhs) noexcept;
Texture& operator=(Texture&& rhs) noexcept;
void... |
diegomacario/Quaternion-Experiments | inc/game_object_3D.h | #ifndef GAME_OBJECT_3D_H
#define GAME_OBJECT_3D_H
#include <glm/glm.hpp>
#include <memory>
#include "model.h"
#include "quat.h"
class GameObject3D
{
public:
GameObject3D(const std::shared_ptr<Model>& model,
const glm::vec3& position,
float ang... |
diegomacario/Quaternion-Experiments | inc/play_state.h | #ifndef PLAY_STATE_H
#define PLAY_STATE_H
#include <array>
#include "game.h"
#include "line.h"
class PlayState : public State
{
public:
PlayState(const std::shared_ptr<FiniteStateMachine>& finiteStateMachine,
const std::shared_ptr<Window>& window,
const std::shared_p... |
diegomacario/Quaternion-Experiments | inc/mesh.h | <reponame>diegomacario/Quaternion-Experiments
#ifndef MESH_H
#define MESH_H
#include <assimp/scene.h>
#include <memory>
#include <vector>
#include <bitset>
#include "shader.h"
#include "texture.h"
struct Vertex
{
Vertex(const glm::vec3& position,
const glm::vec3& normal,
const glm::vec2& texC... |
diegomacario/Quaternion-Experiments | inc/game.h | #ifndef GAME_H
#define GAME_H
#include "model.h"
#include "game_object_3D.h"
#include "camera.h"
#include "window.h"
#include "state.h"
#include "finite_state_machine.h"
class Game
{
public:
Game();
~Game();
Game(const Game&) = delete;
Game& operator=(const Game&) = delete;
Game(Game&&) = delete;
... |
diegomacario/Quaternion-Experiments | inc/shader_loader.h | <filename>inc/shader_loader.h
#ifndef SHADER_LOADER_H
#define SHADER_LOADER_H
#include <memory>
#include "shader.h"
class ShaderLoader
{
public:
ShaderLoader() = default;
~ShaderLoader() = default;
ShaderLoader(const ShaderLoader&) = default;
ShaderLoader& operator=(const ShaderLoader&) = default;
... |
diegomacario/Quaternion-Experiments | inc/resource_manager.h | #ifndef RESOURCE_MANAGER_H
#define RESOURCE_MANAGER_H
#include <memory>
#include <unordered_map>
#include <iostream>
template<typename TResource>
class ResourceManager
{
public:
ResourceManager() = default;
~ResourceManager() = default;
ResourceManager(const ResourceManager&) = delete;
ResourceManager& ... |
diegomacario/Quaternion-Experiments | inc/shader.h | <reponame>diegomacario/Quaternion-Experiments<filename>inc/shader.h<gh_stars>100-1000
#ifndef SHADER_H
#define SHADER_H
#include <glad/glad.h>
#include <glm/glm.hpp>
#include <string>
class Shader
{
public:
explicit Shader(unsigned int shaderProgID);
~Shader();
Shader(const Shader&) = delete;
Shader& o... |
diegomacario/Quaternion-Experiments | inc/finite_state_machine.h | <reponame>diegomacario/Quaternion-Experiments
#ifndef FINITE_STATE_MACHINE_H
#define FINITE_STATE_MACHINE_H
#include <unordered_map>
#include <memory>
#include "state.h"
class FiniteStateMachine
{
public:
FiniteStateMachine() = default;
~FiniteStateMachine() = default;
FiniteStateMachine(const FiniteState... |
digaru19/MIPS_Emulator | Qt/mainwindow.h | #ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QStringListModel>
#include <QLineEdit>
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
void display_register_values();
v... |
digaru19/MIPS_Emulator | src/instructions.h | <filename>src/instructions.h
#ifndef MIPS_INSTRUCTIONS_SET_H
#define MIPS_INSTRUCTIONS_SET_H
#include "datapath_elements.h"
#include <vector>
#include <string>
#include <string.h>
#include <stdlib.h>
using namespace std;
class Instruction_Set {
public:
virtual void execute() = 0;
static Instruction_Se... |
digaru19/MIPS_Emulator | src/datapath_elements.h | <reponame>digaru19/MIPS_Emulator
#include <vector>
#include <string>
#include "instructions.h"
#include <string.h>
#ifndef MIPS_EMULATOR_H
#define MIPS_EMULATOR_H
using namespace std;
int get_reg_no(string);
class Instruction_Set;
class Registers {
// There are 34 registers, instead of 32, for strogin the va... |
patil215/v8 | src/ia32/frame-constants-ia32.h | <filename>src/ia32/frame-constants-ia32.h
// Copyright 2012 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_IA32_FRAME_CONSTANTS_IA32_H_
#define V8_IA32_FRAME_CONSTANTS_IA32_H_
#include "src/base/macros.h"
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.