repo_name stringlengths 6 97 | path stringlengths 3 341 | text stringlengths 8 1.02M |
|---|---|---|
mohamed-abdelhameed/voroffset | src/vor3d/VoronoiBruteForce.h | #pragma once
#include"vor3d/Voronoi.h"
namespace voroffset3d
{
class VoronoiMorphoBruteForce : public VoronoiMorpho
{
typedef std::pair<double, int> MyPoint;
public:
virtual void dilation(CompressedVolume input, CompressedVolume &result, double radius, double &time_1, double &time_2) override;
privat... |
mohamed-abdelhameed/voroffset | src/vor3d/VoronoiVorPower.h | <reponame>mohamed-abdelhameed/voroffset
#pragma once
#include"vor3d/Voronoi.h"
namespace voroffset3d
{
class VoronoiMorphoVorPower : public VoronoiMorpho
{
public:
virtual void dilation(CompressedVolume input, CompressedVolume &result, double radius, double &time_1, double &time_2) override;
private:
double ... |
mohamed-abdelhameed/voroffset | src/vor3d/Morpho2D.h | <filename>src/vor3d/Morpho2D.h
#pragma once
////////////////////////////////////////////////////////////////////////////////
#include "vor3d/Common.h"
#include <iostream>
#include <vector>
#include <array>
#include <set>
////////////////////////////////////////////////////////////////////////////////
namespace vorof... |
mohamed-abdelhameed/voroffset | src/vor3d/Timer.h | <gh_stars>10-100
#pragma once
#include <iostream>
#include <chrono>
struct Timer
{
public:
// Public time point typedef
typedef std::chrono::steady_clock::time_point TimePoint;
// Compute time difference
template<typename clock_t>
static auto elapsed(std::chrono::time_point<clock_t> &t1)
{
using namespace st... |
mohamed-abdelhameed/voroffset | src/vor3d/CompressedVolumeWithRadii.h | #pragma once
////////////////////////////////////////////////////////////////////////////////
#include "vor3d/CompressedVolumeBase.h"
////////////////////////////////////////////////////////////////////////////////
namespace voroffset3d
{
class CompressedVolumeWithRadii : public CompressedVolumeBase
{
private:
... |
mohamed-abdelhameed/voroffset | src/vor2d/DoubleCompressedImage.h | #pragma once
////////////////////////////////////////////////////////////////////////////////
#include "vor2d/Common.h"
#include "vor2d/Image.h"
#include <set>
#include <limits>
#include <cassert>
#include <vector>
////////////////////////////////////////////////////////////////////////////////
//////////////////////... |
mohamed-abdelhameed/voroffset | src/vor3d/HalfDilationOperator.h | <filename>src/vor3d/HalfDilationOperator.h
#pragma once
#include "vor3d/CompressedVolumeBase.h"
#include "vor3d/CompressedVolume.h"
#include "vor3d/CompressedVolumeWithRadii.h"
#include "vor3d/Morpho2D.h"
namespace voroffset3d
{
/**
* @brief Forward sweep for dilation operation.
*
* @param[in] vor { T... |
mohamed-abdelhameed/voroffset | src/vor3d/CompressedVolumeBase.h | #pragma once
////////////////////////////////////////////////////////////////////////////////
#include "vor3d/Common.h"
#include <set>
#include <limits>
#include <cassert>
#include <vector>
////////////////////////////////////////////////////////////////////////////////
namespace voroffset3d
{
class CompressedVolum... |
liuwd8/cocos2d-x | thunder/Classes/Thunder.h | #ifndef __THUNDER_H__
#define __THUNDER_H__
#include "cocos2d.h"
#include "SimpleAudioEngine.h"
USING_NS_CC;
using namespace std;
class Thunder : public cocos2d::Layer {
public:
// there's no 'id' in cpp, so we recommend returning the class instance pointer
static cocos2d::Scene* createScene();
// Here's a differ... |
liuwd8/cocos2d-x | NetworkAccess/Classes/ModifyUserScene.h | #pragma once
#ifndef __MODIFY_USER_SCENE_H__
#define __MODIFY_USER_SCENE_H__
#include "cocos2d.h"
#include "ui\CocosGUI.h"
#include "Utils.h"
#include "network\HttpClient.h"
#include "json\document.h"
using namespace cocos2d::ui;
using namespace cocos2d::network;
using namespace rapidjson;
USING_NS_CC;
class Modify... |
liuwd8/cocos2d-x | NetworkAccess/Classes/UsersInfoScene.h | #pragma once
#ifndef __USER_INFO_SCENE_H__
#define __USER_INFO_SCENE_H__
#include "cocos2d.h"
#include "ui\CocosGUI.h"
#include "network\HttpClient.h"
#include "json\document.h"
#include "json\writer.h"
#include "Utils.h"
#include <regex>
USING_NS_CC;
using namespace cocos2d::network;
using namespace rapidjson;
usin... |
liuwd8/cocos2d-x | NetworkAccess/Classes/Utils.h | <reponame>liuwd8/cocos2d-x
#pragma once
#include <string>
#include "json\document.h"
std::string serializeRapidjsonDocument(const rapidjson::Document &doc);
// In C++11, it's ok to use std::to_string
std::string intToStr(int i); |
liuwd8/cocos2d-x | GoldMiner/Classes/GameScene.h | <reponame>liuwd8/cocos2d-x
#pragma once
#include <stdio.h>
#include "cocos2d.h"
USING_NS_CC;
class GameSence : public cocos2d::Scene
{
public:
static cocos2d::Scene* createScene();
virtual bool init();
virtual bool onTouchBegan(Touch *touch, Event *unused_event, Sprite* mouse);
virtual void shootMenuCallback(Re... |
liuwd8/cocos2d-x | NetworkAccess/Classes/LoginRegisterScene.h | <reponame>liuwd8/cocos2d-x
#pragma once
#ifndef __LOGIN_REGISTER_SCENE_H__
#define __LOGIN_REGISTER_SCENE_H__
#include "cocos2d.h"
#include "ui\CocosGUI.h"
#include "network\HttpClient.h"
#include "json\writer.h"
#include "json\document.h"
#include "Utils.h"
using namespace cocos2d::network;
using namespace cocos2d:... |
liuwd8/cocos2d-x | GoldMiner/Classes/MenuScene.h | #pragma once
#include <stdio.h>
#include "cocos2d.h"
class MenuScene : public cocos2d::Scene
{
public:
static cocos2d::Scene* createScene();
virtual bool init();
// a selector callback
void startMenuCallback(cocos2d::Ref* pSender);
// implement the "static create()" method manually
CREATE_... |
sp0lsh/island | apps/examples/multi_window_example/multi_window_example_app/multi_window_example_app.h | #ifndef GUARD_multi_window_example_app_H
#define GUARD_multi_window_example_app_H
#endif
#include <stdint.h>
#include "le_core/le_core.h"
// depends on le_backend_vk. le_backend_vk must be loaded before this class is used.
void register_multi_window_example_app_api( void *api );
struct multi_window_example_app_o;
... |
sp0lsh/island | modules/le_file_watcher/le_tweakable.h | <reponame>sp0lsh/island
#ifndef GUARD_PAL_TWEAKABLE_H
#define GUARD_PAL_TWEAKABLE_H
/*
Tweakable allows you to tweak numerical parameters. It will only work in debug mode,
and in Release mode it will melt down to nothing.
Each compilation unit which has tweaks must include this header, and must, at the
most ... |
sp0lsh/island | modules/le_backend_vk/le_backend_types_internal.h | <reponame>sp0lsh/island<gh_stars>0
#include "le_backend_vk.h"
// NOTE: This header *must not* be included by anyone else but le_backend_vk.cpp or le_pipeline_builder.cpp.
// Its sole purpose of being is to create a dependency inversion, so that both these compilation units
// may share the same types for c... |
sp0lsh/island | modules/le_path/le_path.h | #ifndef GUARD_le_path_H
#define GUARD_le_path_H
/* le_path
*
* 2D vector graphics, with minimal useful support for SVG-style commands.
*
*/
#include "le_core/le_core.h"
#include <glm/fwd.hpp> // TODO: get rid of glm as this is a cpp header.
struct le_path_o;
// clang-format off
struct le_path_api {
struct str... |
sp0lsh/island | apps/examples/hello_world/hello_world_app/hello_world_app.h | <gh_stars>0
#ifndef GUARD_hello_world_app_H
#define GUARD_hello_world_app_H
#endif
#include <stdint.h>
#include "le_core/le_core.h"
struct hello_world_app_o;
// clang-format off
struct hello_world_app_api {
struct hello_world_app_interface_t {
hello_world_app_o * ( *create )();
void ( *des... |
sp0lsh/island | apps/examples/asterisks/asterisks_app/hershey.h | //
// Hershey Vector Font
// Based on the hershey character set
//
// Compiled by <NAME>
// October 1997
//
// via: http://paulbourke.net/dataformats/hershey/
//
// C-Style Coordinate array for the SIMPLEX character set
//
// The following array describes each character in a way suitable for a C program. The charac... |
sp0lsh/island | modules/le_mesh_generator/le_mesh_generator.h | <gh_stars>0
#ifndef GUARD_le_mesh_generator_H
#define GUARD_le_mesh_generator_H
#include "le_core/le_core.h"
struct le_mesh_o;
// clang-format off
struct le_mesh_generator_api {
struct le_mesh_generator_interface_t {
void ( *generate_sphere )(
le_mesh_o * mesh,
float radius, ... |
sp0lsh/island | apps/templates/quad_template/quad_template_app/quad_template_app.h | #ifndef GUARD_quad_template_app_H
#define GUARD_quad_template_app_H
#endif
#include "le_core/le_core.h"
// depends on le_backend_vk. le_backend_vk must be loaded before this class is used.
struct quad_template_app_o;
// clang-format off
struct quad_template_app_api {
struct quad_template_app_interface_t {
quad_... |
sp0lsh/island | modules/le_ui_event/le_ui_event.h | #pragma once
#include <stdint.h>
// Todo: move this to a frame-work wide internal header file.
struct LeUiEvent {
enum class NamedKey : int32_t {
eUnknown = -1,
/* Printable keys */
eSpace = 32,
eApostrophe = 39, /* ' */
eComma = 44, /* , */
eMinus = 45, /* - */
ePeriod = ... |
sp0lsh/island | modules/le_resource_manager/le_resource_manager.h | <gh_stars>0
#ifndef GUARD_le_resource_manager_H
#define GUARD_le_resource_manager_H
/*
# ResourceManager
Helper module for dealing with image resources. ResourceManager automatically
loads image resources from file, and uploads image resources, and declares
image resources to a rendermodule.
Once an image was uploa... |
sp0lsh/island | modules/le_pipeline_builder/le_pipeline_builder.h | #ifndef GUARD_le_graphics_pipeline_builder_H
#define GUARD_le_graphics_pipeline_builder_H
#include "le_core/le_core.h"
struct le_shader_module_o;
struct le_pipeline_manager_o;
LE_OPAQUE_HANDLE( le_gpso_handle ); // Opaque handle for graphics pipeline state
LE_OPAQUE_HANDLE( le_cpso_handle ); // Opaque handle for... |
sp0lsh/island | modules/le_midi/le_midi.h | #ifndef GUARD_le_midi_H
#define GUARD_le_midi_H
#include "le_core/le_core.h"
struct le_midi_o;
/*
We would like a double-buffered midi approach, where you can query the current stream of messages,
and flip on frame change. This means that there will be at most one frame of input lag, but sequencing
will be perfectl... |
sp0lsh/island | modules/le_gltf/cgltf.c | <filename>modules/le_gltf/cgltf.c
#define CGLTF_IMPLEMENTATION
#include "3rdparty/cgltf/cgltf.h"
|
sp0lsh/island | apps/examples/hello_triangle/hello_triangle_app/hello_triangle_app.h | #ifndef GUARD_hello_triangle_app_H
#define GUARD_hello_triangle_app_H
#endif
#include "le_core/le_core.h"
// depends on le_backend_vk. le_backend_vk must be loaded before this class is used.
struct hello_triangle_app_o;
// clang-format off
struct hello_triangle_app_api {
struct hello_triangle_app_interface_t {
... |
sp0lsh/island | modules/le_parameter_twister/le_parameter_twister.h | #ifndef GUARD_le_parameter_twister_H
#define GUARD_le_parameter_twister_H
#include "le_core/le_core.h"
struct le_parameter_twister_o;
struct le_parameter_o;
// clang-format off
struct le_parameter_twister_api {
struct le_parameter_twister_interface_t {
le_parameter_twister_o * ( * create ) ... |
sp0lsh/island | modules/le_pixels/le_pixels.h | #ifndef GUARD_le_pixels_H
#define GUARD_le_pixels_H
#include "le_core/le_core.h"
struct le_pixels_o;
struct le_pixels_info {
// Note that we store the log2 of the number of Bytes needed to store values of a type
// in the least significant two bits, so that we can say: numBytes = 1 << (type & 0x03);
enum Type : ... |
sp0lsh/island | modules/le_swapchain_vk/le_swapchain_vk.h | #ifndef GUARD_LE_SWAPCHAIN_VK_H
#define GUARD_LE_SWAPCHAIN_VK_H
#include <stdint.h>
#include "le_core/le_core.h"
struct le_swapchain_o;
struct le_backend_o;
struct VkDevice_T;
struct VkPhysicalDevice_T;
struct VkSurfaceKHR_T;
struct VkSemaphore_T;
struct VkImage_T;
struct VkImageView_T;
struct VkQueue_T;
struct VkSu... |
sp0lsh/island | modules/le_jobs/le_jobs.h | <reponame>sp0lsh/island<gh_stars>0
#ifndef GUARD_le_jobs_H
#define GUARD_le_jobs_H
#include "le_core/le_core.h"
// clang-format off
struct le_jobs_api {
struct counter_t;
typedef void ( *fun_ptr_t )( void * );
/* A Job is a function pointer with a complete_counter which gets decreased
* once the job is compl... |
sp0lsh/island | modules/le_jobs/private/lockfree_ring_buffer.h | #ifndef _LOCK_FREE_RING_BUFFER_H_
#define _LOCK_FREE_RING_BUFFER_H_
#include <stdint.h>
#include <stddef.h>
struct lockfree_ring_buffer_t;
lockfree_ring_buffer_t *lockfree_ring_buffer_create( uint32_t power_of_2_size );
void lockfree_ring_buffer_destroy( lockfree_ring_buffer_t *rb );
size_t ... |
sp0lsh/island | apps/examples/lut_grading_example/lut_grading_example_app/lut_grading_example_app.h | <filename>apps/examples/lut_grading_example/lut_grading_example_app/lut_grading_example_app.h
#ifndef GUARD_lut_grading_example_app_H
#define GUARD_lut_grading_example_app_H
#endif
#include "le_core/le_core.h"
// depends on le_backend_vk. le_backend_vk must be loaded before this class is used.
struct lut_grading_exa... |
sp0lsh/island | modules/le_camera/le_camera.h | #ifndef GUARD_le_camera_H
#define GUARD_le_camera_H
#include "le_core/le_core.h"
#ifdef __cplusplus
# ifndef ISL_ALLOW_GLM_TYPES
# define ISL_ALLOW_GLM_TYPES 1
# endif
// Life is terrible without 3d type primitives, so let's include some glm forward declarations
# if ( ISL_ALLOW_GLM_TYPES == 1 )
# include <glm/f... |
sp0lsh/island | modules/le_backend_vk/le_backend_vk.h | <gh_stars>0
#ifndef GUARD_LE_BACKEND_VK_H
#define GUARD_LE_BACKEND_VK_H
#include <stdint.h>
#include "le_core/le_core.h"
struct le_backend_o;
struct le_backend_vk_api;
struct le_swapchain_settings_t;
struct le_window_o;
struct le_backend_vk_instance_o; // defined in le_instance_vk.cpp
struct le_device_o; ... |
sp0lsh/island | modules/le_2d/le_2d.h | <reponame>sp0lsh/island<filename>modules/le_2d/le_2d.h
#ifndef GUARD_le_2d_H
#define GUARD_le_2d_H
/* Le2D is a 2D drawing context with the aim of making drawing in 2d simple, and intuitive.
*
* Drawing is stateless - each draw command needs their attributes explicitly set.
*
*/
#include "le_core/le_core.h"
#... |
sp0lsh/island | modules/le_mesh/le_mesh_types.h | #ifndef GUARD_le_mesh_types_H
#define GUARD_le_mesh_types_H
#include <stdint.h>
#include <vector>
#include "glm/glm.hpp"
struct le_mesh_o {
std::vector<uint16_t> indices; // list of indices
std::vector<glm::vec3> vertices; // 3d position in model space
std::vector<glm::vec3> normals; // normalised normal, per-v... |
sp0lsh/island | modules/le_rtx_pipeline_builder/le_rtx_pipeline_builder.h | #ifndef GUARD_le_rtx_pipeline_builder_H
#define GUARD_le_rtx_pipeline_builder_H
#include "le_core/le_core.h"
struct le_rtx_pipeline_builder_o;
struct le_rtx_pso_handle_t; // opaque handle for rtx pipleine
LE_OPAQUE_HANDLE( le_rtx_pso_handle );
// clang-format off
struct le_rtx_pipeline_builder_api {
struct le_rtx... |
sp0lsh/island | modules/le_core/le_core.h | <reponame>sp0lsh/island<filename>modules/le_core/le_core.h
#ifndef GUARD_API_REGISTRY_HPP
#define GUARD_API_REGISTRY_HPP
#include <stdint.h>
#include <stddef.h> // for size_t
/*
The core at heart is a global, canonical, table of apis,
indexed via a hash of their name.
The core may be included from any compila... |
SandeepAggarwal/SAIssueTracker | Classes/CHelperMethods.c | <gh_stars>0
//
// CHelperMethods.c
// SAIssueTracker
//
// Created by <NAME> on 10/07/17.
// Copyright © 2017 <NAME>. All rights reserved.
//
// https://stackoverflow.com/a/4746378/3632958
#include "CHelperMethods.h"
#include <assert.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/sysctl.h>
bool amI... |
SandeepAggarwal/SAIssueTracker | Classes/CHelperMethods.h | <filename>Classes/CHelperMethods.h<gh_stars>0
//
// CHelperMethods.h
// SAIssueTracker
//
// Created by <NAME> on 11/07/17.
// Copyright © 2017 <NAME>. All rights reserved.
//
#ifndef CHelperMethods_h
#define CHelperMethods_h
#endif /* CHelperMethods_h */
#include <stdbool.h>
bool amIAttachedToDebugger();
|
codeonwort/pathosengine | projects/Test_SkeletalAnimation/src/bone.h | <reponame>codeonwort/pathosengine<gh_stars>10-100
#pragma once
#include <string>
#include <vector>
namespace pathos {
struct Bone {
public:
std::string name;
std::vector<float> weights;
std::vector<unsigned int> vertexIDs;
glm::mat4 offset;
glm::mat4 finalTransform;
};
} |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/input/input_constants.h | <gh_stars>10-100
#pragma once
namespace pathos {
enum class InputConstants {
UNDEFINED,
// Keyboard
KEYBOARD_A,
KEYBOARD_B,
KEYBOARD_C,
KEYBOARD_D,
KEYBOARD_E,
KEYBOARD_F,
KEYBOARD_G,
KEYBOARD_H,
KEYBOARD_I,
KEYBOARD_J,
KEYBOARD_K,
KEYBOARD_L,
KEYBOARD_M,
KEYBOARD_N,
KEYBOARD_O,
... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/engine.h | #pragma once
#include "badger/types/noncopyable.h"
#include "badger/types/int_types.h"
#include "badger/memory/mem_alloc.h"
#include "badger/system/stopwatch.h"
#include "pathos/input/input_system.h"
#include <map>
#include <list>
#include <mutex>
#include <memory>
#include <string>
#include <functional>
#include "g... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/util/renderdoc_integration.h | <gh_stars>10-100
#pragma once
#define WIN32
#include "renderdoc/api/app/renderdoc_app.h"
namespace pathos {
class RenderDocIntegration {
public:
static RenderDocIntegration& get();
private:
RenderDocIntegration();
~RenderDocIntegration();
RenderDocIntegration(const RenderDocIntegration&) = d... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/render/deferred/deferredpass_pack_bumptexture.h | #pragma once
#include "deferredpass_pack_base.h"
namespace pathos {
// Bump mapping implementation by simple normal mapping
class MeshDeferredRenderPass_Pack_BumpTexture : public MeshDeferredRenderPass_Pack {
public:
MeshDeferredRenderPass_Pack_BumpTexture();
virtual void render(RenderCommandList& cmdList, ... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/loader/scene_loader.h | <reponame>codeonwort/pathosengine<filename>projects/PathosEngine/src/pathos/loader/scene_loader.h
// Load a scene from a scene description file.
// #note-scene: Actually pathos::Scene does not corresponds with scene description
// as actors are owned by pathos::World. The scene description is mainly for a static scene... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/util/color_conversion.h | #pragma once
#undef min
#undef max
#include <stdint.h>
#include <algorithm>
inline uint32_t to_uint(float r, float g, float b, float a = 1.0) {
uint32_t R = static_cast<uint32_t>(r * 255.0f);
uint32_t G = static_cast<uint32_t>(g * 255.0f);
uint32_t B = static_cast<uint32_t>(b * 255.0f);
uint32_t A = static_cast<... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/light/light_all.h | #pragma once
#include "directional_light_actor.h"
#include "directional_light_component.h"
#include "point_light_actor.h"
#include "point_light_component.h"
|
codeonwort/pathosengine | projects/PathosEngine/src/pathos/loader/colladaloader.h | <reponame>codeonwort/pathosengine
#pragma once
#define DEPRECATED
#ifndef DEPRECATED
#include "pathos/mesh/mesh.h"
#include "assimp/scene.h"
#include <vector>
namespace pathos {
class ColladaLoader {
public:
ColladaLoader(const char* file);
inline const Geometries& getGeometries() { return geometries; }
p... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/input/input_manager.h | #pragma once
#include "badger/types/int_types.h"
#include "pathos/input/input_constants.h"
#include "pathos/input/xinput_manager.h"
#include <functional>
#include <vector>
#include <map>
namespace pathos {
//struct InputKey {
// InputConstants keyCode;
//
// // Special states
// uint8 capsLock : 1;
// uint8 c... |
codeonwort/pathosengine | projects/PathosEngine/src/badger/thread/cpu.h | #pragma once
#include "badger/types/int_types.h"
class CPU final {
public:
static uint32 getTotalLogicalCoreCount();
// #note-cpu: It can change within a single function. Usually it's good to use thread id instead.
static uint32 getCurrentLogicalCoreIndex();
// #todo-cpu: If needed, search for GetLogicalProces... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/render/sky_ansel.h | <reponame>codeonwort/pathosengine<gh_stars>10-100
#pragma once
#include "sky.h"
#include "pathos/mesh/geometry.h"
#include "gl_core.h"
namespace pathos {
class IcosahedronGeometry : public MeshGeometry {
static constexpr uint32_t INITIAL_NUM_VERTICES = 12;
static constexpr uint32_t INITIAL_NUM_TRIANLGES = 20;
... |
codeonwort/pathosengine | projects/PathosEngine/src/badger/types/matrix_types.h | <filename>projects/PathosEngine/src/badger/types/matrix_types.h
#pragma once
#include "glm/detail/type_mat.hpp"
using matrix2 = glm::mat2x2;
using matrix3 = glm::mat3x3;
using matrix4 = glm::mat4x4;
using matrix3x4 = glm::mat3x4;
using matrix4x3 = glm::mat4x3;
|
codeonwort/pathosengine | projects/PathosEngine/src/pathos/light/shadow_directional.h | <reponame>codeonwort/pathosengine
#pragma once
#include "gl_core.h"
#include "pathos/camera/camera.h"
#include "pathos/scene/scene.h"
#include "badger/types/noncopyable.h"
#include "badger/types/vector_types.h"
#include "badger/types/matrix_types.h"
#include <vector>
namespace pathos {
// Shadow pass for a directi... |
codeonwort/pathosengine | projects/Test_DeferredRenderer/src/galaxy_gen.h | <reponame>codeonwort/pathosengine
#pragma once
#include "gl_core.h"
using namespace pathos;
namespace pathos {
class OpenGLDevice;
class PlaneGeometry;
}
class GalaxyGenerator {
public:
static void createStarField(GLuint& targetTexture, uint32 width, uint32 height);
static void internal_createResources(OpenGLD... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/light/directional_light_component.h | <reponame>codeonwort/pathosengine
#pragma once
#include "pathos/actor/scene_component.h"
namespace pathos {
struct DirectionalLightProxy : public SceneComponentProxy {
vector3 wsDirection;
float padding0;
vector3 radiance;
float padding1;
vector3 vsDirection;
float padding2;
};
class Directiona... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/render/render_device.h | <reponame>codeonwort/pathosengine
#pragma once
#include "badger/types/noncopyable.h"
#include "render_command_list.h"
#include "pathos/thread/engine_thread.h"
#include <functional>
#include <memory>
// Device API wrapper
#define REQUIRED_GL_MAJOR_VERSION 4
#define REQUIRED_GL_MINOR_VERSION 6
#define GL_DEBUG_CONT... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/mesh/static_mesh_actor.h | #pragma once
#include "static_mesh_component.h"
#include "pathos/actor/actor.h"
namespace pathos {
class Mesh;
class StaticMeshActor : public Actor {
public:
StaticMeshActor() {
meshComponent = createDefaultComponent<StaticMeshComponent>();
setAsRootComponent(meshComponent);
}
void setStaticMesh(M... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/util/math_lib.h | #pragma once
#include <glm/glm.hpp>
#undef min
#undef max
namespace pathos {
// Given N (assuming normalized), returns two arbitrary vectors T and B to form an orthonormal basis.
inline void calculateOrthonormalBasis(const glm::vec3& N, glm::vec3& outT, glm::vec3& outB) {
glm::vec3 T(0.0f, 1.0f, 0.0f);
// if... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/named_object.h | <reponame>codeonwort/pathosengine
#pragma once
#include <string>
namespace pathos {
class NamedObject {
public:
const std::string& getName() const;
void setName(const std::string& n);
private:
std::string name = "";
};
}
|
codeonwort/pathosengine | projects/PathosEngine/src/badger/math/rotator.h | #pragma once
#include "badger/math/minmax.h"
#include "badger/types/vector_types.h"
#include "badger/types/matrix_types.h"
// Yaw-pitch-roll
struct Rotator {
static Rotator directionToYawPitch(const vector3& dir);
Rotator()
: yaw(0.0f)
, pitch(0.0f)
, roll(0.0f)
{}
Rotator(float inYaw, float inPitch, flo... |
codeonwort/pathosengine | projects/Test_RacingGame/src/player_controller.h | <filename>projects/Test_RacingGame/src/player_controller.h
#pragma once
#include "pathos/actor/actor.h"
using namespace pathos;
class PlayerController : public Actor
{
public:
virtual void onSpawn() override;
virtual void onTick(float deltaSeconds) override;
void setPlayerPawn(Actor* player);
void togglePhotoMo... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/render/postprocessing/ssao.h | #pragma once
#include "post_process.h"
#include "pathos/shader/uniform_buffer.h"
namespace pathos {
class SSAO : public PostProcess {
struct UBO_SSAO_Random {
glm::vec4 points[256];
glm::vec4 randomVectors[256];
};
public:
virtual void initializeResources(RenderCommandList& cmdList) override;
virtu... |
codeonwort/pathosengine | projects/PathosEngine/src/badger/types/vector_types.h | <reponame>codeonwort/pathosengine
#pragma once
#include "glm/glm.hpp"
using vector2 = glm::vec2;
using vector3 = glm::vec3;
using vector4 = glm::vec4;
|
codeonwort/pathosengine | projects/PathosEngine/src/pathos/actor/actor_component.h | <gh_stars>10-100
#pragma once
namespace pathos {
class Actor;
class Scene;
class ActorComponent
{
friend class Actor;
friend class Scene; // For render proxy
public:
ActorComponent() = default;
~ActorComponent() = default;
void unregisterFromParent();
inline Actor* getOwner() const { return owner... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/render/deferred/deferredpass_pack_base.h | #pragma once
//#include "pathos/mesh/mesh.h"
#include "pathos/mesh/geometry.h"
#include "pathos/material/material.h"
#include "pathos/scene/scene.h"
#include "pathos/camera/camera.h"
#include "pathos/shader/uniform_buffer.h"
namespace pathos {
class MeshDeferredRenderPass_Pack {
public:
virtual ~MeshDeferredRen... |
codeonwort/pathosengine | projects/PathosEngine/src/badger/assertion/assertion.h | #pragma once
#include <assert.h>
void CHECK_IMPL(int x, const char* file, int line);
void CHECKF_IMPL(int x, const char* msg, const char* file, int line);
#ifndef ASSERT
#define ASSERT(x) assert(x)
#endif
#ifndef CHECK
#define CHECK(x) CHECK_IMPL(!!(x), __FILE__, __LINE__)
#endif
#ifndef CHECKF
#define CHECKF(x... |
codeonwort/pathosengine | projects/PathosEngine/src/badger/memory/mem_alloc.h | // Custom memory allocators.
#pragma once
#include "badger/types/int_types.h"
#include <stdlib.h>
class StackAllocator
{
public:
explicit StackAllocator(uint32 bytes);
~StackAllocator();
void* alloc(uint32 bytes);
void clear();
bool isClear() const;
private:
void* memblock;
void* current;
uint32 totalByt... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/text/textmesh.h | <gh_stars>10-100
#pragma once
#include <string>
#include <map>
#include "gl_core.h"
#include "pathos/mesh/mesh.h"
#include "pathos/text/font_texture_cache.h"
namespace pathos {
class TextGeometry : public MeshGeometry {
public:
void configure(FontTextureCache& cache, const std::wstring& text);
private:
std:... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/render/render_command_list.generated.h | <filename>projects/PathosEngine/src/pathos/render/render_command_list.generated.h
void cullFace(
GLenum mode)
{
RenderCommand_cullFace* __restrict packet = (RenderCommand_cullFace*)getNextPacket();
packet->pfn_execute = PFN_EXECUTE(RenderCommand_cullFace::execute);
packet->mode = mode;
}
void frontFace(
GLenum mod... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/render/render_deferred.h | #pragma once
#include "renderer.h"
#include "scene_render_targets.h"
#include "deferred/deferredpass.h"
#include "postprocessing/anti_aliasing.h"
#include "pathos/shader/uniform_buffer.h"
#include "pathos/camera/camera.h"
#include "pathos/scene/scene.h"
#include "pathos/light/shadow_directional.h"
#include "pathos/lig... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/render/render_command_list.h | #pragma once
#include "render_commands.h"
#include "badger/memory/mem_alloc.h"
#include "badger/assertion/assertion.h"
#include <vector>
#include <functional>
namespace pathos {
class RenderCommandList {
static const uint32 RENDER_COMMAND_LIST_MAX_MEMORY;
static const uint32 COMMAND_PARAMETERS_MAX_MEMORY;
... |
codeonwort/pathosengine | projects/PathosEngine/src/gl_core.h | <reponame>codeonwort/pathosengine
#pragma once
// Include this header to use OpenGL API.
#include "GL/gl3w.h"
#include "glm/glm.hpp"
#include "glm/gtc/constants.hpp"
#include "glm/gtc/matrix_transform.hpp"
#include "pathos/util/gl_debug_group.h"
|
codeonwort/pathosengine | projects/PathosEngine/src/pathos/text/font_texture_cache.h | <gh_stars>10-100
#pragma once
// Rather than copying each glyph to a texture everytime when render a text,
// let's hold glyphs in a texture and only pass (u,v,w,h)
// But Unicode characters are too many that they cannot be stored in a single texture.
// Only recently used glyphs are maintained in a limited number of... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/overlay/display_object.h | <gh_stars>10-100
#pragma once
#include "pathos/named_object.h"
#include "pathos/mesh/geometry.h"
#include "pathos/wrapper/transform.h"
#include <vector>
namespace pathos {
class DisplayObject2D : public NamedObject {
public:
static DisplayObject2D* createRoot();
DisplayObject2D();
virtual ~DisplayObject2D()... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/input/xinput_manager.h | #pragma once
#include "badger/types/int_types.h"
#include "badger/types/os.h"
#include "pathos/input/input_constants.h"
#include <vector>
namespace pathos {
enum class XInputUserIndex : uint32
{
USER0 = 0,
USER1 = 1,
USER2 = 2,
USER3 = 3,
MAX_USERS = 4
};
struct XInputState
{
XInputState()
: co... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/render/postprocessing/anti_aliasing.h | <reponame>codeonwort/pathosengine<gh_stars>10-100
#pragma once
#include "badger/types/int_types.h"
namespace pathos {
enum class EAntiAliasingMethod : uint8 {
NoAA = 0,
FXAA = 1,
// #todo-anti-aliasing: TAA
NumMethods = 2
};
}
|
codeonwort/pathosengine | projects/PathosEngine/src/pathos/actor/world.h | <reponame>codeonwort/pathosengine
#pragma once
#include "badger/types/noncopyable.h"
#include "pathos/scene/scene.h"
#include "pathos/camera/camera.h"
namespace pathos {
class World : public Noncopyable {
friend class Scene;
friend class Engine;
public:
World();
virtual ~World() {}
public:
template<t... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/render/depth_prepass.h | #pragma once
#include "badger/types/noncopyable.h"
#include "render_command_list.h"
#include "pathos/shader/uniform_buffer.h"
namespace pathos {
class Scene;
class Camera;
// Render only scene depth without any shading.
//
// The result can be utilized in various situations:
// - Generate HiZ for hardware oc... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/util/file_system.h | <filename>projects/PathosEngine/src/pathos/util/file_system.h
#pragma once
#include <string>
namespace pathos {
// Path of the exectuable
void getExecPath(std::wstring& outPath);
// Directory that contains the exectuable
void getExecDir(std::wstring& outDir);
std::string getFullDirectoryPath(const char* targe... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/render/postprocessing/post_process.h | #pragma once
#include "pathos/render/render_command_list.h"
#include "pathos/mesh/geometry_primitive.h"
#include "badger/types/int_types.h"
#include <vector>
namespace pathos {
enum class EPostProcessInput : uint8 {
PPI_0 = 0,
PPI_1,
PPI_2,
PPI_3,
PPI_4,
PPI_5,
PPI_6,
PPI_7,
PPI_8,
PPI_9,
PPI... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/render/render_commands.h | <filename>projects/PathosEngine/src/pathos/render/render_commands.h
#pragma once
#include "badger/types/int_types.h"
#include "gl_core.h"
namespace pathos {
struct RenderCommandBase;
union RenderCommandPacketUnion;
typedef void (APIENTRYP PFN_EXECUTE)(const RenderCommandBase* __restrict params);
struct RenderC... |
codeonwort/pathosengine | projects/PathosEngine/src/badger/system/stopwatch.h | <filename>projects/PathosEngine/src/badger/system/stopwatch.h
#pragma once
#include <chrono>
struct Stopwatch {
public:
Stopwatch() {
startTime = std::chrono::system_clock::now();
}
void start() {
startTime = std::chrono::system_clock::now();
}
// Elapsed seconds since start()
float stop() {
std::chron... |
codeonwort/pathosengine | projects/Test_SkeletalAnimation/src/world2.h | #pragma once
#include "pathos/engine.h"
#include "pathos/actor/world.h"
using namespace pathos;
//////////////////////////////////////////////////////////////////////////
namespace pathos {
class StaticMeshActor;
class SkinnedMesh;
class DirectionalLightActor;
class PointLightActor;
}
class PlayerController;
cl... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/loader/imageloader.h | <reponame>codeonwort/pathosengine<filename>projects/PathosEngine/src/pathos/loader/imageloader.h
#pragma once
#include "gl_core.h"
#include <FreeImage.h>
#include <array>
namespace pathos {
class VolumeTexture;
void initializeImageLibrary();
void destroyImageLibrary();
struct HDRImageMetadata {
float* data;... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/loader/asset_streamer.h | // Asynchronous load manager for various assets (images, 3d models, and so on)
#pragma once
#include "badger/types/int_types.h"
#include "badger/memory/mem_alloc.h"
#include "badger/thread/thread_pool.h"
#include <list>
#include <mutex>
#include <functional>
namespace pathos {
class AssetStreamer;
class OBJLoade... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/render/scene_render_targets.h | #pragma once
#include "render_command_list.h"
namespace pathos {
// Textures for scene rendering
// #todo-renderer: render target pool for temporary textures
struct SceneRenderTargets {
private:
bool destroyed = false;
public:
uint32 sceneWidth;
uint32 sceneHeight;
uint32 numCascades = 4;
uint32 c... |
codeonwort/pathosengine | projects/Test_DeferredRenderer/src/world_rc1.h | #pragma once
#include "pathos/engine.h"
#include "pathos/actor/world.h"
#include "pathos/mesh/static_mesh_actor.h"
using namespace pathos;
#include <vector>
#include "badger/math/spline.h"
namespace pathos {
class ProceduralGeometry;
class ColorMaterial;
class OBJLoader;
}
class PlayerController;
class LightningA... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/light/directional_light_actor.h | <filename>projects/PathosEngine/src/pathos/light/directional_light_actor.h<gh_stars>10-100
#pragma once
#include "pathos/actor/actor.h"
#include "pathos/light/directional_light_component.h"
namespace pathos {
class DirectionalLightActor : public Actor {
public:
DirectionalLightActor() {
lightComponent = crea... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/loader/objloader.h | <gh_stars>10-100
#pragma once
#include "tiny_obj_loader.h"
#include "pathos/loader/imageloader.h"
#include "pathos/mesh/mesh.h"
#include <vector>
#include <map>
#include <set>
namespace pathos {
struct PendingTextures {
PendingTextures() = default;
PendingTextures(FIBITMAP* inAlbedo, FIBITMAP* inNormal, FIBITM... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/overlay/rectangle.h | <reponame>codeonwort/pathosengine<gh_stars>10-100
#pragma once
#include "display_object.h"
#include "pathos/mesh/geometry_primitive.h"
namespace pathos {
class Rectangle : public DisplayObject2D {
public:
Rectangle(float inWidth, float inHeight);
virtual ~Rectangle();
void setSize(float inWidth, float inHe... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/scene/scene_capture_component.h | #pragma once
#include "pathos/actor/scene_component.h"
#include "gl_core.h"
#include <vector>
namespace pathos {
class SceneComponent;
class RenderTarget2D;
// Captures the scene at its current location and rotation, and then write the result to a render target.
// Basically it performs whole scene rendering a... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/render/overlay/overlaypass_standard.h | #pragma once
#include "overlaypass_base.h"
namespace pathos {
// standard render pass that uses color and texture
class OverlayPass_Standard : public OverlayPass {
public:
OverlayPass_Standard();
~OverlayPass_Standard();
virtual void renderOverlay(RenderCommandList& cmdList, DisplayObject2D* object, const... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/mesh/model_transform.h | <reponame>codeonwort/pathosengine
#pragma once
#include "badger/types/vector_types.h"
#include "badger/math/rotator.h"
namespace pathos {
// Traditional scale-rotation-translation matrix
struct ModelTransform {
ModelTransform();
ModelTransform(const vector3& inLocation, const Rotator& inRotation, const vector... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/wrapper/transform.h | #pragma once
#include <glm/glm.hpp>
namespace pathos {
// #todo-deprecated: Remove this
class Transform {
protected:
glm::mat4 matrix;
public:
Transform();
Transform(const glm::mat4& matrix);
const glm::mat4& getMatrix() const;
inline void copyFrom(const glm::mat4& m) { matrix = m; }
inline glm::v... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/shader/shader_program.h | #pragma once
#include "gl_core.h"
#include <string>
#include <vector>
#include <map>
namespace pathos {
// Forward decl.
class ShaderProgram;
class ShaderStage;
// Needed to traverse shader programs for runtime reload.
class ShaderDB final {
public:
static ShaderDB& get() {
static ShaderDB instance;
... |
codeonwort/pathosengine | projects/PathosEngine/src/pathos/render/deferred/deferredpass_unpack.h | <gh_stars>10-100
#pragma once
#include "pathos/mesh/geometry.h"
#include "pathos/mesh/geometry_primitive.h"
#include "pathos/material/material.h"
#include "pathos/scene/scene.h"
#include "pathos/camera/camera.h"
#include "pathos/shader/uniform_buffer.h"
namespace pathos {
class MeshDeferredRenderPass_Unpack {
pub... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.