repo_name stringlengths 6 97 | path stringlengths 3 341 | text stringlengths 8 1.02M |
|---|---|---|
jeanleflambeur/silkopter | silkopter/fc/src/simulator/Multirotor_Simulation.h | #pragma once
#include "common/node/IMultirotor_Simulator.h"
#include "common/stream/IMultirotor_Simulator_State.h"
#include "uav_properties/IMultirotor_Properties.h"
#include "utils/Clock.h"
#include "messages.def.h"
class btCylinderShapeZ;
class btMotionState;
class btRigidBody;
class btDefaultCollisionCo... |
jeanleflambeur/silkopter | def_lang/include/def_lang/ast/Attribute.h | #pragma once
#include <boost/variant.hpp>
#include "def_lang/Serialization.h"
#include "def_lang/Result.h"
namespace ts
{
namespace ast
{
class Attribute
{
public:
enum class Type
{
STRING,
BOOL,
INTEGRAL,
FLOAT,
DOUBLE
};
Attribute();
Attribute(std::stri... |
jeanleflambeur/silkopter | q/include/video/Sampler.h | #pragma once
#include "Ptr_Fw_Declaration.h"
namespace q
{
namespace video
{
class Sampler
{
public:
enum class Type : uint8_t
{
TEXTURE_2D,
TEXTURE_CUBE
};
enum class Filter : uint8_t
{
NEAREST,
BILINEAR,
TRILINEAR
};
enum class Wrap : uint8_t
{
WRAP... |
jeanleflambeur/silkopter | qdata/include/data/File_Source.h | #pragma once
namespace q
{
namespace data
{
class File_Source;
DECLARE_CLASS_PTR(File_Source);
class File_Source : public Source
{
public:
File_Source(Path const& path);
virtual ~File_Source();
size_t get_size() const;
bool is_open() const;
size_t read(uint8_t* buffer, size_t size);
... |
jeanleflambeur/silkopter | silkopter/gs/src/stream_viewers/Numeric_Viewer_Widget.h | <filename>silkopter/gs/src/stream_viewers/Numeric_Viewer_Widget.h
#pragma once
#include <boost/thread.hpp>
#include "Comms.h"
#include "ui_Numeric_Viewer_Widget.h"
#include <QtCharts/QLineSeries>
#include <QtCharts/QValueAxis>
class Numeric_Viewer_Widget : public QWidget
{
public:
Numeric_Viewer_Widget(QWidget *... |
jeanleflambeur/silkopter | silkopter/fc/src/generator/Vec3_Generator.h | <gh_stars>10-100
#pragma once
#include "HAL.h"
#include "common/node/IGenerator.h"
#include "generator/Oscillator.h"
#include "Basic_Output_Stream.h"
#include "hal.def.h"
namespace silk
{
namespace node
{
template<class Stream_t>
class Vec3_Generator : public IGenerator
{
public:
Vec3_Generator(HAL& hal);
... |
jeanleflambeur/silkopter | def_lang/include/def_lang/impl/Numeric_Value_Template.h | #pragma once
#include "def_lang/INumeric_Type_Template.h"
#include "def_lang/INumeric_Value_Template.h"
#include "def_lang/ep/Value_Template_EP.h"
#include "def_lang/IInitializer_List.h"
#include "def_lang/ILiteral_Initializer.h"
#include "def_lang/ILiteral.h"
#include "def_lang/impl/Initializer_List.h"
#include "def_... |
jeanleflambeur/silkopter | silkopter/fc/src/HAL.h | <filename>silkopter/fc/src/HAL.h
#pragma once
#include <memory>
#include <map>
#include <vector>
#include <chrono>
#include "uav_properties/IUAV_Properties.h"
#include "common/bus/IBus.h"
#include "common/node/INode.h"
#include "common/stream/IStream.h"
#include "utils/Clock.h"
#include "MPL_Helper.h"
namespace sil... |
jeanleflambeur/silkopter | silkopter/fc/src/GS_Comms.h | <filename>silkopter/fc/src/GS_Comms.h<gh_stars>10-100
#pragma once
#include "common/Comm_Data.h"
#include "HAL.h"
#include "common/Manual_Clock.h"
#include "common/node/ISource.h"
#include "common/stream/IMultirotor_Commands.h"
#include "common/stream/IMultirotor_State.h"
#include "common/stream/IVideo.h"
#include "u... |
jeanleflambeur/silkopter | silkopter/fc/src/processor/ADC_Voltmeter.h | <gh_stars>10-100
#pragma once
#include "HAL.h"
#include "common/stream/IADC.h"
#include "common/stream/IVoltage.h"
#include "common/node/IProcessor.h"
#include "Sample_Accumulator.h"
#include "Basic_Output_Stream.h"
namespace silk
{
namespace hal
{
struct ADC_Voltmeter_Descriptor;
struct ADC_Voltmeter_Config;
}
}
... |
jeanleflambeur/silkopter | qdata/include/data/Memory_Source.h | #pragma once
namespace q
{
namespace data
{
class Memory_Sink;
class Memory_Source : public Source
{
friend class Memory_Sink;
public:
Memory_Source();
Memory_Source(std::vector<uint8_t>&& data);
Memory_Source(uint8_t const* data, size_t size); //copies the data
virtual ~Memory_Source()... |
jeanleflambeur/silkopter | def_lang/include/def_lang/impl/Vector_Value.h | #pragma once
#include "def_lang/IVector_Type.h"
#include "def_lang/IVector_Value.h"
namespace ts
{
class Vector_Value final : virtual public IVector_Value
{
public:
Vector_Value(std::shared_ptr<IVector_Type const> type);
~Vector_Value();
Result<bool> is_equal(IValue const& other) const override;
bo... |
jeanleflambeur/silkopter | silkopter/libs/utils/comms/ISocket.h | <reponame>jeanleflambeur/silkopter
#pragma once
namespace util
{
namespace comms
{
//socket interface
class ISocket
{
public:
virtual ~ISocket() = default;
enum class Result
{
OK,
ERROR,
RECONNECTED,
};
virtual auto process() -> Result = 0;
std::function<void(uint8_... |
jeanleflambeur/silkopter | q/include/video/GLES/GLES_Vertex_Buffer.h | <filename>q/include/video/GLES/GLES_Vertex_Buffer.h<gh_stars>10-100
#pragma once
#include "GLES_Buffer_Impl.h"
#include "video/Vertex_Buffer.h"
namespace q
{
namespace video
{
class GLES_Vertex_Buffer : public Vertex_Buffer
{
public:
GLES_Vertex_Buffer();
~GLES_Vertex_Buffer();
virtual bool... |
jeanleflambeur/silkopter | silkopter/libs/common/stream/IBattery_State.h | #pragma once
#include "Stream_Base.h"
#include "ICurrent.h"
#include "IVoltage.h"
namespace silk
{
namespace stream
{
class IBattery_State : public IScalar_Stream<Semantic::BATTERY_STATE>
{
public:
typedef std::false_type can_be_filtered_t;
struct Value
{
float charge_used = 0; //Amperes-Hour (A... |
jeanleflambeur/silkopter | def_lang/include/def_lang/impl/All_Numeric_Types.h | <reponame>jeanleflambeur/silkopter
#pragma once
#include "Numeric_Type_Template.h"
#include "def_lang/All_INumeric_Types.h"
namespace ts
{
template<typename Traits> class Numeric_Value_Template;
template<typename Traits> class Numeric_Type_Template;
template<class T> struct Scalar_Numeric_Traits : public Scalar_IN... |
jeanleflambeur/silkopter | silkopter/gs/src/value_editors/Bool_Value_Editor.h | <reponame>jeanleflambeur/silkopter
#pragma once
#include "IValue_Editor.h"
#include "Qualified_Value.h"
class QCheckBox;
class Bool_Value_Editor : public IValue_Editor
{
public:
Bool_Value_Editor(const Qualified_Value<ts::IBool_Value>& qualified_value, std::string const& suffix_str);
~Bool_Value_E... |
jeanleflambeur/silkopter | qbase/include/mem/Embedded_Allocator.h | #pragma once
//#include <cstddef>
//#include <cstdint>
#include <util/Noncopyable.h>
namespace q
{
namespace mem
{
template <std::size_t N>
class Arena : util::Noncopyable
{
static std::size_t const alignment = 16;
char m_buffer[N + alignment];
char* m_start_ptr;
char* m_ptr;
std::size_t a... |
jeanleflambeur/silkopter | def_lang/include/def_lang/Source_Location.h | #pragma once
#include <string>
#include <stdint.h>
namespace ts
{
//////////////////////////////////////////////////////////////////////////
class Source_Location
{
public:
Source_Location() = default;
Source_Location(std::string const&, uint32_t line, uint32_t column);
void set_line(std:... |
jeanleflambeur/silkopter | def_lang/include/def_lang/IVariant_Value.h | <gh_stars>10-100
#pragma once
#include "IValue.h"
namespace ts
{
class IVariant_Type;
class IVariant_Value : virtual public IValue
{
public:
virtual ~IVariant_Value() = default;
virtual std::shared_ptr<IVariant_Type const> get_specialized_type() const = 0;
virtual Result<void> set_value_type(std::shar... |
jeanleflambeur/silkopter | silkopter/libs/utils/comms/UDP_Socket.h | <filename>silkopter/libs/utils/comms/UDP_Socket.h
#pragma once
#include "ISocket.h"
#include <thread>
#include "utils/Clock.h"
#include <functional>
#include <asio.hpp>
namespace boost
{
namespace system
{
class error_code;
}
namespace asio
{
namespace ip
{
class address;
}
}
}
namespace util
{
namespace comms
{
c... |
jeanleflambeur/silkopter | silkopter/libs/utils/hw/IUART.h | #pragma once
namespace util
{
namespace hw
{
class IUART
{
public:
virtual ~IUART() = default;
virtual size_t read(uint8_t* data, size_t max_size) = 0;
virtual bool write(uint8_t const* data, size_t size) = 0;
virtual void send_break() = 0;
};
}
}
|
jeanleflambeur/silkopter | silkopter/gs/src/Properties_Delegate.h | #pragma once
#include "value_editors/IValue_Editor.h"
#include <QStyledItemDelegate>
class Value_Editor_Factory;
//////////////////////////////////////////////////////////////////////////
class Properties_Delegate : public QStyledItemDelegate
{
Q_OBJECT;
public:
Properties_Delegate(QObject* parent... |
jeanleflambeur/silkopter | qdata/include/data/Zip_Data_Pack.h | <reponame>jeanleflambeur/silkopter
#pragma once
namespace q
{
namespace data
{
class Zip_Data_Pack : public Data_Pack
{
public:
Zip_Data_Pack(Path const& path);
Zip_Data_Pack(File_System_ptr file_system, Path const& path);
virtual ~Zip_Data_Pack();
size_t get_count() const;
Path c... |
jeanleflambeur/silkopter | q/include/scene/Frustum.h | #pragma once
#include "util/Bounds.h"
namespace q
{
namespace scene
{
//! Defines the view frustum. That's the space visible by the camera.
/** The view frustum is enclosed by 6 planes. These six planes share
four points. A bounding box around these four points is also stored in
this structure.
*/
... |
jeanleflambeur/silkopter | q/include/video/Uniform.h | #pragma once
#include "mem/auto_buffer.h"
namespace q
{
namespace video
{
class Uniform
{
public:
enum class Type : uint8_t
{
BOOL,
INT,
FLOAT,
VEC2,
VEC3,
VEC4,
MAT3,
MAT4
};
public:
Uniform();
Uniform(Type type, size_t count, uint8_t* data = 0);
... |
jeanleflambeur/silkopter | qinput/include/QInput.h | <filename>qinput/include/QInput.h
#include "QInputStdAfx.h"
namespace qinput
{
class Touch;
DECLARE_CLASS_PTR(Touch);
class Gamepad;
DECLARE_CLASS_PTR(Gamepad);
}
#include "Touch.h"
#include "Touchscreen.h"
#include "Keyboard.h"
#include "Sensors.h"
#include "Gamepad.h"
#include "Input_Mgr.h"
... |
jeanleflambeur/silkopter | silkopter/rc/src/Comms.h | <reponame>jeanleflambeur/silkopter<gh_stars>10-100
#pragma once
#include <mutex>
#include <thread>
#include <deque>
#include <atomic>
#include "common/Comm_Data.h"
#include "common/stream/IAcceleration.h"
#include "common/stream/IADC.h"
#include "common/stream/IFloat.h"
#include "common/stream/IBool.h"
#include "comm... |
jeanleflambeur/silkopter | qmath/include/qmath/plane.h | <reponame>jeanleflambeur/silkopter<gh_stars>10-100
#pragma once
namespace math
{
//! Enumeration for intersection relations of 3d objects
enum RelationEnum
{
k_relFront = 0,
k_relBack,
k_relPlanar,
k_relSpanning,
k_relClipping
};
//! Template plane class with some intersection testing methods.
t... |
jeanleflambeur/silkopter | silkopter/fc/src/source/EHealth.h | <filename>silkopter/fc/src/source/EHealth.h<gh_stars>10-100
#pragma once
#include "HAL.h"
#include "common/node/ISource.h"
#include "common/stream/IAcceleration.h"
#include "common/bus/IUART.h"
namespace silk
{
namespace node
{
class EHealth : public ISource
{
public:
EHealth(HAL& hal);
~EHealth();
ts... |
jeanleflambeur/silkopter | q/include/video/GLES/GLES_Render_Target.h | <gh_stars>10-100
#pragma once
#include "GLES_Fbo_Wrapper.h"
namespace q
{
namespace video
{
class Command_Stream;
class GLES_Render_Target : public GLES_Fbo_Wrapper
{
friend class Command_Stream;
public:
GLES_Render_Target() = default;
~GLES_Render_Target();
bool allocate(math::ve... |
jeanleflambeur/silkopter | silkopter/gs/src/value_editors/Vec4f_Value_Editor.h | <filename>silkopter/gs/src/value_editors/Vec4f_Value_Editor.h
#pragma once
#include "IValue_Editor.h"
#include "Qualified_Value.h"
class VecX_Value_Editor_Helper;
class Vec4f_Value_Editor : public IValue_Editor
{
public:
Vec4f_Value_Editor(const Qualified_Value<ts::IVec4f_Value>& qualified_value, std::... |
jeanleflambeur/silkopter | qdata/include/data/Data_Pack.h | #pragma once
namespace q
{
namespace data
{
class Data_Pack;
DECLARE_CLASS_PTR(Data_Pack);
class Data_Pack : public util::Noncopyable
{
public:
virtual ~Data_Pack() {}
virtual auto get_count() const -> size_t = 0;
virtual auto get_path(size_t idx) const -> Path const& = 0;
virtual aut... |
jeanleflambeur/silkopter | qmath/include/qmath/func_range.h | <reponame>jeanleflambeur/silkopter
#pragma once
namespace math
{
//min
template<typename T> vec2<T> min(vec2<T> const& a, vec2<T> const& b);
template<typename T> vec3<T> min(vec3<T> const& a, vec3<T> const& b);
template<typename T> vec4<T> min(vec4<T> const& a, vec4<T> const& b);
template<typename T> T mi... |
jeanleflambeur/silkopter | silkopter/gs_old/src/GS.h | <gh_stars>10-100
#pragma once
#include <QtWidgets/QMainWindow>
#include "ui_GS.h"
#include "qcustomplot.h"
#include "Comms.h"
#include "Render_Widget.h"
class Multi_Config_Window;
class HAL_Window;
class Sim_Window;
class IHUD_Widget;
class GS : public QMainWindow
{
public:
GS(QWidget *parent = 0);
... |
jeanleflambeur/silkopter | q/src/res/Impl/PVR_Loader.h | #pragma once
#include "res/Loader.h"
#include "video/Texture.h"
namespace q
{
namespace res
{
namespace impl
{
//handles PVR containers
class PVR_Texture_Loader : public res::Loader<video::Texture>
{
virtual void load(Path const& path, data::Source& source, video::Texture& r) const;
virtual bo... |
jeanleflambeur/silkopter | silkopter/gs_old/src/Custom_Item_Delegate.h | #pragma once
#include <QStyledItemDelegate>
#include <QDoubleSpinBox>
class Custom_Item_Delegate : public QStyledItemDelegate
{
Q_OBJECT
public:
Custom_Item_Delegate(QObject* parent = 0)
: QStyledItemDelegate(parent)
{
}
QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& ... |
jeanleflambeur/silkopter | silkopter/rc/src/ISticks.h | #pragma once
#include "IInput_Device.h"
namespace silk
{
class ISticks : public IInput_Device
{
public:
virtual ~ISticks() = default;
enum class Raw_Type
{
WITHOUT_REMAPPING,
WITHOUT_DEADBAND
};
virtual float get_raw_yaw(Raw_Type raw_type) const = 0;
virtual float get_yaw() ... |
jeanleflambeur/silkopter | silkopter/gs/src/value_editors/Vec2i_Value_Editor.h | #pragma once
#include "IValue_Editor.h"
#include "Qualified_Value.h"
class VecX_Value_Editor_Helper;
class Vec2i_Value_Editor : public IValue_Editor
{
public:
Vec2i_Value_Editor(const Qualified_Value<ts::IVec2i_Value>& qualified_value, std::string const& suffix_str);
QWidget* get_widget() overri... |
jeanleflambeur/silkopter | silkopter/libs/utils/hw/II2C.h | #pragma once
#include <cstdint>
#include <memory>
namespace util
{
namespace hw
{
class II2C
{
public:
virtual ~II2C() = default;
virtual bool read(uint8_t address, uint8_t* data, size_t size) = 0;
virtual bool write(uint8_t address, uint8_t const* data, size_t size) = 0;
virtual bool read_register... |
jeanleflambeur/silkopter | silkopter/fc/src/source/Raspicam.h | <reponame>jeanleflambeur/silkopter
#pragma once
#include "HAL.h"
#include "common/node/ISource.h"
#include "common/Comm_Data.h"
#include "common/stream/IVideo.h"
#include <thread>
#include <fstream>
#include <thread>
#include <atomic>
#include "common/stream/IPWM.h"
#include "common/stream/ICamera_Comma... |
jeanleflambeur/silkopter | def_lang/include/def_lang/ep/Type_Template_EP.h | #pragma once
#include <memory>
#include "def_lang/IValue.h"
#include "def_lang/IString_Value.h"
#include "def_lang/ep/Symbol_EP.h"
#include "def_lang/ep/Attribute_Container_EP.h"
#include "def_lang/ILiteral_Attribute.h"
namespace ts
{
template<typename Traits>
class Type_Template_EP : public virtual Traits::type_int... |
jeanleflambeur/silkopter | silkopter/fc/def/hal.def.h | #pragma once
#include <stdint.h>
#include <string>
#include <vector>
#include <memory>
#include <cfloat>
#include <boost/variant.hpp>
#include <def_lang/Result.h>
#include <def_lang/Serialization.h>
#include "gen_support.h"
namespace silk
{
namespace hal
{
template<class T>
struct Poly
{
Poly() = default;
explic... |
jeanleflambeur/silkopter | silkopter/libs/utils/hw/SPI_BCM.h | #pragma once
#include "ISPI.h"
#include <atomic>
#include <vector>
namespace util
{
namespace hw
{
class SPI_BCM : public ISPI
{
public:
SPI_BCM();
~SPI_BCM();
ts::Result<void> init(uint32_t channel, uint32_t speed, uint32_t mode);
bool transfer(void const* tx_data, void* rx_data, size_t size, uint... |
jeanleflambeur/silkopter | silkopter/libs/common/params/Integral_Param.h | #pragma once
#include "ParamEP.h"
namespace silk
{
namespace params
{
class Integral_Param : public ParamEP
{
public:
typedef int32_t value_t;
Integral_Param(q::Path const& path,
std::string const& ui_prefix,
std::string const& ui_suffix,
std::string const& ui_name,
value_t value = 0,
val... |
jeanleflambeur/silkopter | qbase/include/util/Format.h | #pragma once
#ifndef Q_ANDROID
# include <boost/optional.hpp>
#endif
#include <set>
#include <vector>
#include <FString.h>
#include <cassert>
namespace q
{
namespace util
{
namespace formatting
{
struct Placeholder
{
Placeholder() : alignment(0), precision(0), fixed_precision(0), base_... |
jeanleflambeur/silkopter | def_lang/include/def_lang/INumeric_Type_Template.h | #pragma once
#include "IType.h"
namespace ts
{
template<typename Traits>
class INumeric_Type_Template : virtual public IType
{
public:
virtual ~INumeric_Type_Template() = default;
typedef Traits traits;
virtual std::shared_ptr<typename traits::value_interface> create_specialized_value() const = 0;
... |
jeanleflambeur/silkopter | q/include/video/Vertex_Declaration.h | <gh_stars>10-100
#pragma once
#include "Ptr_Fw_Declaration.h"
namespace q
{
namespace video
{
class Vertex_Declaration
{
friend class Renderer;
friend class Render_Job;
public:
enum class Type : uint8_t
{
FLOAT, //full floating point values
FP_S8, //fixed point in... |
jeanleflambeur/silkopter | qbase/include/Log.h | #pragma once
namespace q
{
namespace logging
{
class Logger;
/////////////////////////////////////////////////////////////////////////////////////
// Loggers
//This adds a new logger to the system.
extern void add_logger(std::unique_ptr<Logger> logger);
//The logger becomes the only logger. All ... |
jeanleflambeur/silkopter | silkopter/gs/src/calibration/Magnetic_Field_Calibration_Wizard.h | <reponame>jeanleflambeur/silkopter<filename>silkopter/gs/src/calibration/Magnetic_Field_Calibration_Wizard.h
#pragma once
#include <QDialog>
#include "Comms.h"
class Magnetic_Field_Calibration_Wizard : public QDialog
{
public:
Magnetic_Field_Calibration_Wizard(silk::Comms& comms,
... |
jeanleflambeur/silkopter | qmath/include/qmath/func_common.h | #pragma once
namespace math
{
//////////////////////////////////////////////////////////////////////////
//func test
template <typename T> struct vec2;
template <typename T> struct vec3;
template <typename T> struct vec4;
template <typename T> struct mat2;
template <typename T> struct mat3;
te... |
jeanleflambeur/silkopter | def_lang/include/def_lang/All_INumeric_Types.h | #pragma once
#include "INumeric_Type_Template.h"
#include "Math.h"
#include <array>
namespace ts
{
template<typename Traits> class INumeric_Value_Template;
template<typename Traits> class INumeric_Type_Template;
template<class T> struct Scalar_INumeric_Traits
{
typedef T fundamental_type;
typedef T componen... |
jeanleflambeur/silkopter | silkopter/fc/src/uav_properties/IMultirotor_Properties.h | <filename>silkopter/fc/src/uav_properties/IMultirotor_Properties.h<gh_stars>10-100
#pragma once
#include "qmath.h"
#include "uav_properties/IUAV_Properties.h"
#include <stdint.h>
#include <vector>
namespace silk
{
class IMultirotor_Properties : public IUAV_Properties
{
public:
virtual ~IMultirotor_Properties() ... |
jeanleflambeur/silkopter | q/include/video/Image.h | #pragma once
namespace q
{
namespace video
{
template<class Color_T>
class Image : public res::Resource
{
public:
typedef Color_T Color_Type;
typedef color::Traits<Color_T> Color_Traits;
Image(Path const& path = Path());
~Image();
void unload();
bool is_valid() const;
void alloc... |
jeanleflambeur/silkopter | qbase/include/Console_Logger.h | <reponame>jeanleflambeur/silkopter
#pragma once
namespace q
{
namespace logging
{
//Simple implementation that writes to console
class Console_Logger : public Logger
{
public:
virtual void log(Level level, std::string const& message) override;
};
}
}
|
jeanleflambeur/silkopter | silkopter/fc/src/simulator/Multirotor_Simulator.h | #pragma once
#include "HAL.h"
#include "common/stream/IAngular_Velocity.h"
#include "common/stream/IAcceleration.h"
#include "common/stream/IMagnetic_Field.h"
#include "common/stream/IPressure.h"
#include "common/stream/ITemperature.h"
#include "common/stream/IDistance.h"
#include "common/stream/IPosition.h"
#include ... |
jeanleflambeur/silkopter | qmath/include/_qmath.h | <filename>qmath/include/_qmath.h
#pragma once
//#include "QBase.h"
#if !defined MATH_ASSERT
# include <assert.h>
# define MATH_ASSERT assert
#endif
#include <algorithm>
#include <limits>
#include <cmath>
#include <string.h>
namespace math
{
static struct ZUninitialized {} uninitialized;
... |
jeanleflambeur/silkopter | def_lang/include/def_lang/IValue.h | #pragma once
#include <boost/signals2.hpp>
#include <memory>
#include "Result.h"
#include "IInitializer_List.h"
#include "impl/Initializer_List.h"
#include "Serialization.h"
namespace ts
{
class IType;
class Value_Selector;
class IValue
{
public:
IValue() = default;
IValue(IValue const&) = delete;
IValu... |
jeanleflambeur/silkopter | q/include/anim/Animation_Node.h | <filename>q/include/anim/Animation_Node.h
#pragma once
namespace q
{
namespace anim
{
class Animation_Node : public util::Noncopyable
{
public:
virtual ~Animation_Node() {}
//Returns a number representing the structure version. If anything in the structure changes, increment the version
... |
jeanleflambeur/silkopter | def_lang/include/def_lang/IVector_Value.h | #pragma once
#include "IValue.h"
#include "IValue_Container.h"
namespace ts
{
class IVector_Type;
class IVector_Value : virtual public IValue, virtual public IValue_Container
{
public:
virtual ~IVector_Value() = default;
virtual Result<std::shared_ptr<IValue>> insert_default_value(size_t idx) = 0;
virt... |
jeanleflambeur/silkopter | def_lang/include/def_lang/IDeclaration_Scope.h | <reponame>jeanleflambeur/silkopter
#pragma once
#include <memory>
#include <boost/optional.hpp>
#include "Result.h"
#include "Symbol_Path.h"
#include "ISymbol.h"
namespace ts
{
class IDeclaration_Scope : public virtual ISymbol
{
public:
virtual ~IDeclaration_Scope() = default;
virtual Result<std::shared_ptr... |
jeanleflambeur/silkopter | silkopter/rc/src/IInput_Device.h | #pragma once
namespace silk
{
class IInput_Device
{
public:
virtual ~IInput_Device() = default;
virtual void process() = 0;
};
}
|
jeanleflambeur/silkopter | def_lang/include/def_lang/ast/Builder.h | <reponame>jeanleflambeur/silkopter
#pragma once
#include <fstream>
#include "def_lang/Result.h"
#include "def_lang/ast/Node.h"
#include "def_lang/Type_System.h"
#include "def_lang/Source_Location.h"
namespace ts
{
namespace ast
{
class Lexer;
}
}
namespace yy
{
class parser;
}
namespace ts
{
namespace ast
{
class ... |
jeanleflambeur/silkopter | silkopter/fc/src/source/AVRADC.h | <filename>silkopter/fc/src/source/AVRADC.h
#pragma once
#include "HAL.h"
#include "common/node/ISource.h"
#include "common/stream/IADC.h"
#include "common/bus/II2C.h"
#include "Basic_Output_Stream.h"
namespace silk
{
namespace hal
{
struct AVRADC_Descriptor;
struct AVRADC_Config;
}
}
namespace silk
{
namespace n... |
jeanleflambeur/silkopter | silkopter/libs/common/node/ITransformer.h | #pragma once
#include "common/node/INode.h"
namespace silk
{
namespace node
{
class ITransformer : public Node_Base<Type::TRANSFORMER>
{
public:
};
}
}
|
jeanleflambeur/silkopter | silkopter/libs/embedded/utils/Buffer.h | #pragma once
#include "qbase.h"
namespace util
{
//a buffer imlementation that calculates the crc of the data added inside
template<class T, size_t SIZE>
class Buffer : q::util::Noncopyable
{
public:
static const size_t MAX_SIZE = SIZE;
size_t size() const
{
return m_size;
}
void cle... |
jeanleflambeur/silkopter | def_lang/include/def_lang/IExpression.h | <gh_stars>10-100
#pragma once
#include <memory>
#include "IInitializer.h"
namespace ts
{
class IType;
class IValue;
class IExpression: public virtual IInitializer
{
public:
virtual ~IExpression() = default;
virtual std::shared_ptr<IType const> get_type() const = 0;
virtual std::shared_ptr<IValue> evalu... |
jeanleflambeur/silkopter | def_lang/include/def_lang/ILiteral_Attribute.h | #pragma once
#include "def_lang/IAttribute.h"
namespace ts
{
class IValue;
class ILiteral_Attribute : public virtual IAttribute
{
public:
virtual IValue const& get_value() const = 0;
};
}
|
jeanleflambeur/silkopter | silkopter/libs/common/stream/IPWM.h | #pragma once
#include "Stream_Base.h"
namespace silk
{
namespace stream
{
class IPWM : public IScalar_Stream<Semantic::PWM>
{
public:
typedef std::true_type can_be_filtered_t;
typedef float Value; //0 .. 1 representing duty cycle
typedef stream::Sample<Value> Sample;
virtual au... |
jeanleflambeur/silkopter | silkopter/libs/common/stream/IMultirotor_State.h | #pragma once
#include "Stream_Base.h"
#include "IFrame.h"
#include "ILinear_Acceleration.h"
#include "IBattery_State.h"
#include "IBattery_State.h"
#include "IPosition.h"
#include "IVelocity.h"
#include "IProximity.h"
#include "IFloat.h"
#include "IVideo.h"
#include "IMultirotor_Commands.h"
#include <boost/optional.... |
jeanleflambeur/silkopter | q/include/video/Uniform_Def.h | <reponame>jeanleflambeur/silkopter
#pragma once
#include "Uniform.h"
namespace q
{
namespace video
{
class Uniform_Def
{
public:
enum class Precision : uint8_t
{
LOW,
MEDIUM,
HIGH
};
Uniform_Def() = default;
Uniform_Def(Uniform_Def const&) = default;
... |
jeanleflambeur/silkopter | qmath/include/qmath/quat.h | <gh_stars>10-100
#pragma once
#include <array>
namespace math
{
template <typename T>
struct quat
{
typedef T value_t;
T x, y, z, w;
static quat<T> const zero;
static quat<T> const one;
static quat<T> const identity;
//////////////////////////////////////////////////////////////////////////... |
jeanleflambeur/silkopter | silkopter/libs/common/stream/ITorque.h | <filename>silkopter/libs/common/stream/ITorque.h
#pragma once
#include "Stream_Base.h"
namespace silk
{
namespace stream
{
template<Space SPACE_VALUE>
class ITorqueT : public ISpatial_Stream<Semantic::TORQUE, SPACE_VALUE>
{
public:
typedef std::true_type can_be_filtered_t;
typedef math::vec3f Va... |
jeanleflambeur/silkopter | qinput/include/Keyboard.h | #pragma once
namespace qinput
{
struct Key_Code
{
enum
{
//all alphanum keys are with their UTF code, uppercase.
//the following are just special keys
UNKNOWN = 0xFFFFFFF, //to force a huge value
//////////////////////////////////////////////////////////////////////////
// Speci... |
jeanleflambeur/silkopter | silkopter/libs/utils/hw/UART_Dev.h | #pragma once
#include "IUART.h"
#include <string>
#include <vector>
#include <atomic>
namespace util
{
namespace hw
{
class UART_Dev : public IUART
{
public:
UART_Dev();
~UART_Dev();
enum class Baud
{
_9600,
_19200,
_38400,
_57600,
_115200,
_230400,
... |
jeanleflambeur/silkopter | def_lang/include/def_lang/Qualified_Type.h | <filename>def_lang/include/def_lang/Qualified_Type.h<gh_stars>10-100
#pragma once
#include "ITemplate_Argument.h"
namespace ts
{
class IType;
class Qualified_Type : virtual public ITemplate_Argument
{
public:
Qualified_Type(std::shared_ptr<const IType> type, bool is_const);
std::shared_ptr<const IType> get_... |
jeanleflambeur/silkopter | silkopter/gs_old/src/Stream_Viewer_Widget.h | <reponame>jeanleflambeur/silkopter
#pragma once
#include "HAL.h"
#include "Comms.h"
class Stream_Viewer_Widget : public QWidget
{
public:
Stream_Viewer_Widget(silk::HAL& hal, silk::Comms& comms, QWidget *parent);
~Stream_Viewer_Widget();
void set_stream_name(std::string const& stream_name);
private:
... |
jeanleflambeur/silkopter | q/include/text/Texter.h | <filename>q/include/text/Texter.h<gh_stars>10-100
#pragma once
#include "draw/Painter.h"
namespace q
{
namespace text
{
class Font;
enum class Anchor : uint8_t
{
BASELINE = 1 << 0,
TOP = 1 << 1,
LEFT = 1 << 2,
HCENTER = 1 << 3,
VCENTER = 1 << 4,
RIGHT = 1 << 5,
BOTTOM = ... |
jeanleflambeur/silkopter | q/include/video/GLES/GLES_Shader.h | <reponame>jeanleflambeur/silkopter
#pragma once
#include "video/Shader.h"
#include "video/GLES/GLES_Interface.h"
#include "video/GLES/GLES_Command_Stream.h"
namespace q
{
namespace video
{
class GLES_Shader : public Shader
{
friend class Command_Stream;
public:
GLES_Shader(Type type, Shader_So... |
jeanleflambeur/silkopter | silkopter/libs/utils/Crc.h | <gh_stars>10-100
#pragma once
#ifdef __AVR__
# include <util/crc16.h>
#else
inline uint16_t _crc16_update(uint16_t crc, uint8_t data)
{
crc ^= data;
for (int i = 7; i >= 0; --i)
{
if (crc & 1)
{
crc = (crc >> 1) ^ 0xA001;
}
else
{
crc >>= 1;
}
}
return c... |
jeanleflambeur/silkopter | def_lang/include/def_lang/IMember_Def_Container.h | <gh_stars>10-100
#pragma once
#include <stdint.h>
#include <memory>
#include <boost/optional.hpp>
#include "Result.h"
namespace ts
{
class IMember_Def;
class IMember_Def_Container
{
public:
virtual ~IMember_Def_Container() = default;
virtual size_t get_member_def_count() const = 0;
virtual Result<void... |
jeanleflambeur/silkopter | silkopter/libs/embedded/utils/Double_Buffer.h | <reponame>jeanleflambeur/silkopter
#pragma once
namespace util
{
template<class T>
class Double_Buffer
{
public:
Double_Buffer()
{
m_data[0] = T();
m_data[1] = T();
}
T& get()
{
uint8_t idx = m_idx;
return m_data[idx];
}
T const& get() const
{
uint8_t idx = m_i... |
jeanleflambeur/silkopter | silkopter/libs/common/stream/IMultirotor_Simulator_State.h | <reponame>jeanleflambeur/silkopter
#pragma once
#include "Stream_Base.h"
#include "IMultirotor_State.h"
namespace silk
{
namespace stream
{
class IMultirotor_Simulator_State : public IScalar_Stream<Semantic::MULTIROTOR_SIMULATOR_STATE>
{
public:
typedef std::false_type can_be_filtered_t;
struct Value
{
... |
jeanleflambeur/silkopter | silkopter/libs/common/stream/IPressure.h | <reponame>jeanleflambeur/silkopter<filename>silkopter/libs/common/stream/IPressure.h
#pragma once
#include "Stream_Base.h"
namespace silk
{
namespace stream
{
class IPressure : public IScalar_Stream<Semantic::PRESSURE>
{
public:
typedef std::true_type can_be_filtered_t;
typedef double Valu... |
jeanleflambeur/silkopter | qmath/include/qmath/packet.h | <gh_stars>10-100
#pragma once
namespace math
{
template<typename T> struct vec2;
template<typename T> struct vec3;
template<typename T> struct vec4;
template<typename T> struct packet2;
template<typename T> struct packet3;
template<typename T> struct packet4;
//GUARANTEED sizeof(packet2<T>) == sizeo... |
jeanleflambeur/silkopter | qmath/include/qmath/vec2.h | #pragma once
#include <array>
namespace math
{
template<typename T> struct vec3;
template<typename T> struct vec4;
template<typename T>
struct vec2
{
typedef T value_t;
T x, y;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
// cons... |
jeanleflambeur/silkopter | silkopter/libs/utils/Queue.h | <reponame>jeanleflambeur/silkopter
#pragma once
#include <deque>
#include <vector>
#include <atomic>
#include <mutex>
#include <condition_variable>
#include <memory>
#include <cassert>
template<typename T> class Queue
{
public:
Queue(size_t max_size);
~Queue();
void exit();
bool push_back(T const& t... |
jeanleflambeur/silkopter | q/include/video/Sampler_Def.h | <reponame>jeanleflambeur/silkopter
#pragma once
#include "Sampler.h"
namespace q
{
namespace video
{
class Sampler_Def
{
public:
//defines the purpose of this sampler
enum class Semantic : uint8_t
{
DIFFUSE,
NORMAL,
LIGHTMAP,
USER
};
public:
... |
jeanleflambeur/silkopter | silkopter/libs/common/bus/ISPI.h | <reponame>jeanleflambeur/silkopter
#pragma once
#include "IBus.h"
#include "utils/hw/ISPI.h"
namespace silk
{
namespace bus
{
class ISPI_Bus: public IBus
{
public:
virtual ~ISPI_Bus() = default;
virtual util::hw::ISPI& get_spi() = 0;
};
}
}
|
jeanleflambeur/silkopter | q/include/video/Shader.h | <reponame>jeanleflambeur/silkopter<filename>q/include/video/Shader.h
#pragma once
#include "Shader_Source.h"
#include "Uniform_Def.h"
#include "Sampler_Def.h"
#include "Attribute_Def.h"
namespace q
{
namespace video
{
class Shader : util::Noncopyable
{
public:
virtual ~Shader() {}
... |
jeanleflambeur/silkopter | def_lang/include/def_lang/IBool_Value.h | <gh_stars>10-100
#pragma once
#include "Result.h"
#include "IValue.h"
#include "ITemplate_Argument.h"
#include "IBool_Type.h"
namespace ts
{
class IBool_Value : virtual public IValue, public virtual ITemplate_Argument
{
public:
virtual ~IBool_Value() = default;
typedef IBool_Traits traits;
virtual std:... |
jeanleflambeur/silkopter | silkopter/fc/src/source/MPU9250.h | #pragma once
#include "HAL.h"
#include "common/node/ISource.h"
#include "common/bus/II2C.h"
#include "common/bus/ISPI.h"
#include "common/stream/IAcceleration.h"
#include "common/stream/IAngular_Velocity.h"
#include "common/stream/IMagnetic_Field.h"
#include "common/stream/ITemperature.h"
#include "Basic_O... |
jeanleflambeur/silkopter | silkopter/rc/src/IStick_Actuators.h | #pragma once
#include "IInput_Device.h"
namespace silk
{
class IStick_Actuators : public virtual IInput_Device
{
public:
virtual ~IStick_Actuators() = default;
virtual bool set_target_yaw(boost::optional<float> value) = 0;
virtual bool set_target_pitch(boost::optional<float> value) = 0;
virtual bool... |
jeanleflambeur/silkopter | def_lang/include/def_lang/IOptional_Value.h | #pragma once
#include "IValue.h"
namespace ts
{
class IOptional_Type;
class IOptional_Value : virtual public IValue
{
public:
virtual ~IOptional_Value() = default;
virtual std::shared_ptr<IOptional_Type const> get_specialized_type() const = 0;
virtual bool is_set() const = 0;
virtual Result<void> ... |
jeanleflambeur/silkopter | qdata/include/QData.h | #pragma once
#include "QDataStdAfx.h"
#include "data/Sink.h"
#include "data/Source.h"
#include "data/Sub_Source.h"
#include "data/Data_Pack.h"
#include "data/File_System.h"
#include "data/File_Sink.h"
#include "data/File_Source.h"
#include "data/Memory_Sink.h"
#include "data/Memory_Source.h"
#include "da... |
jeanleflambeur/silkopter | def_lang/include/def_lang/impl/Optional_Value.h | #pragma once
#include "def_lang/IOptional_Type.h"
#include "def_lang/IOptional_Value.h"
namespace ts
{
class Optional_Value final : virtual public IOptional_Value
{
public:
Optional_Value(std::shared_ptr<IOptional_Type const> type);
bool is_constructed() const override;
Result<bool> is_equal(IValue co... |
jeanleflambeur/silkopter | def_lang/include/def_lang/ep/Member_Def_Container_EP.h | <gh_stars>10-100
#pragma once
#include <vector>
#include "def_lang/IMember_Def_Container.h"
namespace ts
{
class Member_Def_Container_EP : virtual public IMember_Def_Container
{
public:
~Member_Def_Container_EP();
size_t get_member_def_count() const override;
Result<void> add_member_def(std::shared_pt... |
jeanleflambeur/silkopter | silkopter/fc/src/processor/Proximity.h | #pragma once
#include "HAL.h"
#include "common/stream/IDistance.h"
#include "common/stream/IProximity.h"
#include "common/node/IProcessor.h"
#include "Sample_Accumulator.h"
#include "Basic_Output_Stream.h"
namespace silk
{
namespace hal
{
struct Proximity_Descriptor;
struct Proximity_Config;
}
}
namespace silk
{
n... |
jeanleflambeur/silkopter | silkopter/gs/src/Nodes_Widget.h | <filename>silkopter/gs/src/Nodes_Widget.h<gh_stars>10-100
#pragma once
#include <QToolBar>
#include <QGraphicsView>
#include "ITab_Widget.h"
#include "Comms.h"
#include "qneblock.h"
#include "qnodeseditor.h"
#include "qneport.h"
#include "simulator/Simulator.h"
#include <QGraphicsSceneMouseEvent>
class Properties_... |
jeanleflambeur/silkopter | q/include/video/Uniform_Buffer.h | <filename>q/include/video/Uniform_Buffer.h
#pragma once
#include "Buffer.h"
#include "Ptr_Fw_Declaration.h"
namespace q
{
namespace video
{
class Uniform_Buffer : public Buffer
{
public:
virtual ~Uniform_Buffer() {}
static Uniform_Buffer_ptr create();
};
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.