DEPRECATED void set_uniform(const std::string &, const KeyFrame::AnimatedUniform &);
- virtual const Matrix *get_matrix() const { return &matrix; }
+ const Matrix *get_matrix() const override { return &matrix; }
- virtual void setup_render(Renderer &, Tag) const;
+ void setup_render(Renderer &, Tag) const override;
};
} // namespace GL
Loader(Animation &, Collection &);
private:
Loader(Animation &, Collection *);
- virtual void finish();
+ void finish() override;
void check_slopes_and_control(bool, bool);
void add_kf(const KeyFrame *, bool, bool);
public:
ValueCurve(CurveTarget, int, const std::vector<Knot> &);
- virtual void apply(float, Matrix &) const;
- virtual void apply(float, KeyFrame::AnimatedUniform &) const;
+ void apply(float, Matrix &) const override;
+ void apply(float, KeyFrame::AnimatedUniform &) const override;
};
struct ExtractComponent
Target(Placeable &);
- virtual void animation_event(Placeable *, const std::string &, const Variant &);
+ void animation_event(Placeable *, const std::string &, const Variant &) override;
};
std::map<const Placeable *, Target> objects;
void sub_image(unsigned, int, unsigned, const void *);
public:
- virtual AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) { return nullptr; }
- virtual std::size_t get_data_size() const;
- virtual void unload() { }
+ AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) override { return nullptr; }
+ std::size_t get_data_size() const override;
+ void unload() override { }
};
using Texture1DBackend = OpenGLTexture1D;
void sub_image(unsigned, int, int, unsigned, unsigned, const void *);
public:
- virtual std::size_t get_data_size() const;
- virtual void unload();
+ std::size_t get_data_size() const override;
+ void unload() override;
};
using Texture2DBackend = OpenGLTexture2D;
OpenGLTexture2DArray();
public:
- virtual std::size_t get_data_size() const;
+ std::size_t get_data_size() const override;
};
using Texture2DArrayBackend = OpenGLTexture2DArray;
void allocate();
public:
- virtual AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) { return nullptr; }
- virtual std::size_t get_data_size() const;
- virtual void unload() { }
+ AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) override { return nullptr; }
+ std::size_t get_data_size() const override;
+ void unload() override { }
};
using Texture2DMultisampleBackend = OpenGLTexture2DMultisample;
bool is_array() const;
public:
- virtual AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) { return nullptr; }
- virtual std::size_t get_data_size() const;
- virtual void unload() { }
+ AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) override { return nullptr; }
+ std::size_t get_data_size() const override;
+ void unload() override { }
};
using Texture3DBackend = OpenGLTexture3D;
void sub_image(unsigned, unsigned, int, int, unsigned, unsigned, const void *);
public:
- virtual AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) { return nullptr; }
- virtual std::size_t get_data_size() const;
- virtual void unload() { }
+ AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) override { return nullptr; }
+ std::size_t get_data_size() const override;
+ void unload() override { }
};
using TextureCubeBackend = OpenGLTextureCube;
OpenGLWindowView() = default;
- virtual void render();
- virtual const Framebuffer &get_target() const { return sys_framebuf; }
+ void render() override;
+ const Framebuffer &get_target() const override { return sys_framebuf; }
void resize_framebuffer(unsigned, unsigned);
};
SwapChainTexture(PixelFormat, unsigned, unsigned, VkImage);
public:
SwapChainTexture(SwapChainTexture &&) = default;
- ~SwapChainTexture();
+ ~SwapChainTexture() override;
};
} // namespace GL
protected:
VulkanTexture1D();
- virtual void fill_image_info(void *) const;
+ void fill_image_info(void *) const override;
void sub_image(unsigned, int, unsigned, const void *);
- virtual void fill_mipmap_blit(unsigned, void *);
+ void fill_mipmap_blit(unsigned, void *) override;
public:
- virtual AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) { return nullptr; }
- virtual std::size_t get_data_size() const;
- virtual void unload() { }
+ AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) override { return nullptr; }
+ std::size_t get_data_size() const override;
+ void unload() override { }
};
using Texture1DBackend = VulkanTexture1D;
VulkanTexture2D();
- virtual void fill_image_info(void *) const;
+ void fill_image_info(void *) const override;
void sub_image(unsigned, int, int, unsigned, unsigned, const void *);
- virtual void fill_mipmap_blit(unsigned, void *);
+ void fill_mipmap_blit(unsigned, void *) override;
public:
- virtual std::size_t get_data_size() const;
- virtual void unload();
+ std::size_t get_data_size() const override;
+ void unload() override;
};
using Texture2DBackend = VulkanTexture2D;
protected:
VulkanTexture2DArray();
- virtual void fill_image_info(void *) const;
+ void fill_image_info(void *) const override;
};
using Texture2DArrayBackend = VulkanTexture2DArray;
protected:
VulkanTexture2DMultisample();
- virtual void fill_image_info(void *) const;
+ void fill_image_info(void *) const override;
virtual void generate_mipmap();
- virtual void fill_mipmap_blit(unsigned, void *) { }
+ void fill_mipmap_blit(unsigned, void *) override { }
public:
- virtual AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) { return nullptr; }
- virtual std::size_t get_data_size() const;
- virtual void unload() { }
+ AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) override { return nullptr; }
+ std::size_t get_data_size() const override;
+ void unload() override { }
};
using Texture2DMultisampleBackend = VulkanTexture2DMultisample;
VulkanTexture3D();
VulkanTexture3D(unsigned);
- virtual void fill_image_info(void *) const;
+ void fill_image_info(void *) const override;
void sub_image(unsigned, int, int, int, unsigned, unsigned, unsigned, const void *);
- virtual void fill_mipmap_blit(unsigned, void *);
+ void fill_mipmap_blit(unsigned, void *) override;
bool is_array() const;
public:
- virtual AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) { return nullptr; }
- virtual std::size_t get_data_size() const;
- virtual void unload() { }
+ AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) override { return nullptr; }
+ std::size_t get_data_size() const override;
+ void unload() override { }
};
using Texture3DBackend = VulkanTexture3D;
protected:
VulkanTextureCube();
- virtual void fill_image_info(void *) const;
+ void fill_image_info(void *) const override;
void sub_image(unsigned, unsigned, int, int, unsigned, unsigned, const void *);
- virtual void fill_mipmap_blit(unsigned, void *);
+ void fill_mipmap_blit(unsigned, void *) override;
public:
- virtual AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) { return nullptr; }
- virtual std::size_t get_data_size() const;
- virtual void unload() { }
+ AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) override { return nullptr; }
+ std::size_t get_data_size() const override;
+ void unload() override { }
};
using TextureCubeBackend = VulkanTextureCube;
unsigned frame_index = 0;
VulkanWindowView() = default;
- ~VulkanWindowView();
+ ~VulkanWindowView() override;
- virtual void render();
- virtual const Framebuffer &get_target() const { return *current_target; }
+ void render() override;
+ const Framebuffer &get_target() const override { return *current_target; }
void resize_framebuffer(unsigned, unsigned);
};
BoxBuilder(const Vector3 &, const Vector3 &);
using GeometryBuilder::build;
- virtual void build(PrimitiveBuilder &) const;
+ void build(PrimitiveBuilder &) const override;
private:
void build_face(PrimitiveBuilder &, const Vector3 &, const Vector3 &, const Vector3 &) const;
};
CapsuleBuilder(float, float, unsigned = 16, unsigned = 9);
using GeometryBuilder::build;
- virtual void build(PrimitiveBuilder &) const;
+ void build(PrimitiveBuilder &) const override;
};
} // namepace GL
CylinderBuilder(float, float, unsigned = 16);
using GeometryBuilder::build;
- virtual void build(PrimitiveBuilder &) const;
+ void build(PrimitiveBuilder &) const override;
};
} // namespace GL
public:
using GeometryBuilder::build;
- virtual void build(PrimitiveBuilder &) const;
+ void build(PrimitiveBuilder &) const override;
};
} // namespace GL
public:
MeshBuilder(Mesh &);
- ~MeshBuilder();
+ ~MeshBuilder() override;
void auto_offset();
private:
- virtual void begin_();
- virtual void end_();
- virtual void element_(unsigned);
+ void begin_() override;
+ void end_() override;
+ void element_(unsigned) override;
};
} // namespace GL
void element(unsigned);
PrimitiveType get_type() const;
protected:
- virtual void vertex_(const Vector4 &);
+ void vertex_(const Vector4 &) override;
virtual void begin_() = 0;
virtual void end_() = 0;
virtual void element_(unsigned) = 0;
TemplateLoader(typename DataFile::DynamicObjectLoader<typename T::Template>::Collection &c): DataFile::DynamicObjectLoader<typename T::Template>(&c) { }
private:
- virtual typename DataFile::DynamicObjectLoader<typename T::Template>::TypeRegistry &get_type_registry() const { return get_registry<T>(); }
+ typename DataFile::DynamicObjectLoader<typename T::Template>::TypeRegistry &get_type_registry() const override { return get_registry<T>(); }
};
template<typename T>
public:
Loader(SequenceTemplate &, Collection &);
private:
- virtual void init_actions();
+ void init_actions() override;
void clear();
void effect(const std::string &);
public:
Loader(Step &, Collection &);
private:
- virtual void init_actions();
+ void init_actions() override;
public:
void set_inline_base_name(const std::string &);
public:
ClearLoader(SequenceTemplate &);
private:
- virtual void init_actions();
+ void init_actions() override;
void color(float, float, float, float);
void depth(float);
public:
SequenceLoader(Renderable &);
private:
- virtual void init_actions();
+ void init_actions() override;
void renderable(const std::string &, const std::string &);
};
UvSphereBuilder(float, unsigned, unsigned = 0);
using GeometryBuilder::build;
- virtual void build(PrimitiveBuilder &) const;
+ void build(PrimitiveBuilder &) const override;
};
public:
using GeometryBuilder::build;
- virtual void build(PrimitiveBuilder &) const;
+ void build(PrimitiveBuilder &) const override;
private:
unsigned edge_vertex(unsigned, unsigned) const;
VertexArrayBuilder(VertexArray &);
private:
- virtual void vertex_(const Vector4 &);
+ void vertex_(const Vector4 &) override;
template<typename T>
void store_attribute(char *, const Vector4 &, bool, unsigned);
private:
void append_index(unsigned);
- virtual std::size_t get_data_size() const { return data.size(); }
- virtual const void *get_data_pointer() const { return &data[0]; }
- virtual std::size_t get_alignment() const { return get_index_size(); }
+ std::size_t get_data_size() const override { return data.size(); }
+ const void *get_data_pointer() const override { return &data[0]; }
+ std::size_t get_alignment() const override { return get_index_size(); }
public:
std::size_t get_index_size() const { return get_type_size(index_type); }
std::size_t size() const { return data.size()/get_index_size(); }
public:
AsyncLoader(Mesh &, IO::Seekable &);
- ~AsyncLoader();
+ ~AsyncLoader() override;
- virtual bool needs_sync() const;
- virtual bool process();
+ bool needs_sync() const override;
+ bool process() override;
};
enum BufferMask
Mesh() = default;
Mesh(const VertexFormat &);
Mesh(Mesh &&);
- ~Mesh();
+ ~Mesh() override;
/** Sets the vertex format for the mesh. It cannot be changed once set. */
void storage(const VertexFormat &);
void resize_buffers() const;
public:
- virtual int get_load_priority() const { return 1; }
- virtual Resource::AsyncLoader *load(IO::Seekable &, const Resources * = nullptr);
- virtual std::uint64_t get_data_size() const;
- virtual void unload();
+ int get_load_priority() const override { return 1; }
+ Resource::AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) override;
+ std::uint64_t get_data_size() const override;
+ void unload() override;
void set_debug_name(const std::string &);
};
SL::SourceMap source_map;
public:
- virtual Format get_format() const { return GLSL; }
+ Format get_format() const override { return GLSL; }
private:
- virtual void compile(SL::Compiler &);
+ void compile(SL::Compiler &) override;
public:
const std::string &get_prepared_source() const { return prepared_source; }
bool specializable = false;
public:
- virtual Format get_format() const { return SPIR_V; }
+ Format get_format() const override { return SPIR_V; }
/** Loads a SPIR-V binary from a file or other I/O object. */
void load_code(IO::Base &);
private:
- virtual void compile(SL::Compiler &);
+ void compile(SL::Compiler &) override;
void reflect();
public:
SpecializationLoader(std::map<std::string, int> &);
private:
- virtual void init_actions();
+ void init_actions() override;
void specialize_bool(const std::string &, bool);
void specialize_int(const std::string &, int);
private:
Loader(Texture &, Collection *);
- virtual void finish();
+ void finish() override;
protected:
void load_external_image(Graphics::Image &, const std::string &);
GenericLoader(Collection &c): DynamicObjectLoader<Texture>(&c) { }
protected:
- virtual const TypeRegistry &get_type_registry() const { return get_texture_registry(); }
+ const TypeRegistry &get_type_registry() const override { return get_texture_registry(); }
};
protected:
on the image's dimensions. */
virtual void image(const Graphics::Image &, unsigned = 0) = 0;
- virtual std::size_t get_data_size() const { return 0; }
+ std::size_t get_data_size() const override { return 0; }
using TextureBackend::set_debug_name;
cannot be changed once set. */
void storage(PixelFormat, unsigned wd, unsigned lv = 0);
- virtual void image(unsigned level, const void *);
+ void image(unsigned level, const void *) override;
/** Replaces a range of texels in the texture. Allocated storage must
exist. The image data is interpreted according to the storage format and
the range must be fully inside the selected mipmap level. */
void sub_image(unsigned level, unsigned x, unsigned wd, const void *);
- virtual void image(const Graphics::Image &, unsigned = 0);
+ void image(const Graphics::Image &, unsigned = 0) override;
unsigned get_width() const { return width; }
AsyncLoader(Texture2D &, IO::Seekable &);
~AsyncLoader();
- virtual bool needs_sync() const;
- virtual bool process();
+ bool needs_sync() const override;
+ bool process() override;
};
public:
Texture2D() = default;
Texture2D(Texture2D &&) = default;
- virtual ~Texture2D();
+ ~Texture2D() override;
/** Sets storage format and dimensions and allocates memory for the texture.
If lv is zero, a complete mipmap pyramid is automatically created. Storage
AsyncTransfer sub_image_async(unsigned level, unsigned x, unsigned y, unsigned wd, unsigned ht);
- virtual void image(const Graphics::Image &, unsigned = 0);
+ void image(const Graphics::Image &, unsigned = 0) override;
unsigned get_width() const { return width; }
unsigned get_height() const { return height; }
LinAl::Vector<unsigned, 2> get_level_size(unsigned) const;
public:
- virtual Resource::AsyncLoader *load(IO::Seekable &, const Resources * = nullptr);
+ Resource::AsyncLoader *load(IO::Seekable &, const Resources * = nullptr) override;
};
} // namespace GL
for the texture. */
void storage(PixelFormat, unsigned wd, unsigned ht, unsigned sm);
- virtual void image(unsigned, const void *);
- virtual void image(const Graphics::Image &, unsigned = 0);
+ void image(unsigned, const void *) override;
+ void image(const Graphics::Image &, unsigned = 0) override;
unsigned get_width() const { return width; }
unsigned get_height() const { return height; }
/** Replaces contents of an entire mipmap level. Allocated storage must
exist. The image data is interpreted according to the storage format and
must have size matching the selected mipmap level. */
- void image(unsigned level, const void *);
+ void image(unsigned level, const void *) override;
/** Replaces a cuboid-shaped region of the texture. Allocated storage must
exist. The image data is interpreted according to the storage format and
stack of square layers and its height must be divisible by its width. If
storage has not been allocated yet, it will be set to match the image.
Otherwise the image must be compatible with the existing storage. */
- virtual void image(const Graphics::Image &, unsigned = 0);
+ void image(const Graphics::Image &, unsigned = 0) override;
unsigned get_width() const { return width; }
unsigned get_height() const { return height; }
cannot be changed once set. */
void storage(PixelFormat, unsigned size, unsigned lv = 0);
- virtual void image(unsigned, const void *);
+ void image(unsigned, const void *) override;
/** Replaces contents of a single face. Allocated storage must exist. The
image data is interpreted according to the storage format and must have size
stack of square layers and its height must be six times its width. If
storage has not been allocated yet, it will be set to match the image.
Otherwise the image must be compatible with the existing storage. */
- virtual void image(const Graphics::Image &, unsigned = 0);
+ void image(const Graphics::Image &, unsigned = 0) override;
unsigned get_size() const { return size; }
private:
public:
UniformBlock(const ReflectData::BlockInfo &);
- virtual std::size_t get_data_size() const { return data.size(); }
- virtual const void *get_data_pointer() const { return &data[0]; }
+ std::size_t get_data_size() const override { return data.size(); }
+ const void *get_data_pointer() const override { return &data[0]; }
private:
- virtual std::size_t get_alignment() const;
+ std::size_t get_alignment() const override;
public:
void store(const ReflectData::UniformInfo &, std::size_t, const void *);
dirty. */
char *modify(std::size_t);
private:
- virtual std::size_t get_data_size() const;
- virtual const void *get_data_pointer() const { return &data[0]; }
+ std::size_t get_data_size() const override;
+ const void *get_data_pointer() const override { return &data[0]; }
public:
std::size_t size() const { return data.size()/stride; }
float darkness = 1.0f;
float edge_depth_threshold = 0.1f;
- virtual AmbientOcclusion *create(unsigned, unsigned) const;
+ AmbientOcclusion *create(unsigned, unsigned) const override;
};
private:
void set_darkness(float);
- virtual void render(Renderer &, const Texture2D &, const Texture2D &);
+ void render(Renderer &, const Texture2D &, const Texture2D &) override;
- virtual void set_debug_name(const std::string &);
+ void set_debug_name(const std::string &) override;
};
} // namespace GL
float radius = 2.0f;
float strength = 0.2f;
- virtual Bloom *create(unsigned, unsigned) const;
+ Bloom *create(unsigned, unsigned) const override;
};
private:
public:
Bloom(unsigned, unsigned);
- ~Bloom();
+ ~Bloom() override;
/** Sets the σ value of the gaussian blur. Values much larger than 4.0 are
likely to cause artifacts. */
values mean more blurriness. */
void set_strength(float);
- virtual void render(Renderer &, const Texture2D &, const Texture2D &);
+ void render(Renderer &, const Texture2D &, const Texture2D &) override;
- virtual void set_debug_name(const std::string &);
+ void set_debug_name(const std::string &) override;
};
} // namespace GL
float gamma = 1.0f;
bool srgb = false;
- virtual ColorCurve *create(unsigned, unsigned) const;
+ ColorCurve *create(unsigned, unsigned) const override;
};
private:
/// Sets output mapping to linear. This is equivalent to set_gamma(1).
void set_linear();
- virtual void render(Renderer &, const Texture2D &, const Texture2D &);
+ void render(Renderer &, const Texture2D &, const Texture2D &) override;
- virtual void set_debug_name(const std::string &);
+ void set_debug_name(const std::string &) override;
};
} // namespace GL
public:
Loader(Template &, Collection &);
protected:
- virtual void init_actions();
+ void init_actions() override;
private:
void enable_for_method(const std::string &);
protected:
Effect(Renderable &);
public:
- virtual ~Effect() { }
+ ~Effect() override { }
void enable_for_method(Tag);
void disable_for_method(Tag);
bool is_enabled_for_method(Tag) const;
- virtual const Matrix *get_matrix() const { return content.get_matrix(); }
- virtual const Geometry::BoundingSphere<float, 3> *get_bounding_sphere() const { return content.get_bounding_sphere(); }
+ const Matrix *get_matrix() const override { return content.get_matrix(); }
+ const Geometry::BoundingSphere<float, 3> *get_bounding_sphere() const override { return content.get_bounding_sphere(); }
- virtual void setup_frame(Renderer &r) { content.setup_frame(r); }
- virtual void finish_frame() { content.finish_frame(); }
+ void setup_frame(Renderer &r) override { content.setup_frame(r); }
+ void finish_frame() override { content.finish_frame(); }
virtual void set_debug_name(const std::string &) = 0;
};
public:
Loader(Template &, Collection &);
private:
- virtual void init_actions();
+ void init_actions() override;
void fixed_position(float, float, float);
};
float near_clip = 0.1f;
float far_clip = 100.0f;
- virtual EnvironmentMap *create(const std::map<std::string, Renderable *> &) const;
+ EnvironmentMap *create(const std::map<std::string, Renderable *> &) const override;
};
protected:
/** Request that the environment map is updated on the next frame. */
void queue_update();
- virtual void setup_frame(Renderer &);
- virtual void finish_frame();
+ void setup_frame(Renderer &) override;
+ void finish_frame() override;
- virtual void render(Renderer &, Tag = Tag()) const;
+ void render(Renderer &, Tag = Tag()) const override;
- virtual void set_debug_name(const std::string &);
+ void set_debug_name(const std::string &) override;
};
} // namespace GL
public:
Loader(Template &, Collection &);
private:
- virtual void init_actions();
+ void init_actions() override;
void light(const std::string &);
void size_square(unsigned);
public:
Loader(ShadowedLight &);
private:
- virtual void init_actions();
+ void init_actions() override;
};
const Light *light = nullptr;
float depth_bias = 4.0f;
float darkness = 1.0f;
- virtual ShadowMap *create(const std::map<std::string, Renderable *> &) const;
+ ShadowMap *create(const std::map<std::string, Renderable *> &) const override;
};
private:
const Texture2D &get_depth_texture() const { return depth_buf; }
- virtual void setup_frame(Renderer &);
- virtual void finish_frame();
+ void setup_frame(Renderer &) override;
+ void finish_frame() override;
- virtual void render(Renderer &, Tag = Tag()) const;
+ void render(Renderer &, Tag = Tag()) const override;
- virtual void set_debug_name(const std::string &);
+ void set_debug_name(const std::string &) override;
};
} // namespace GL
public:
Loader(Template &, Collection &);
private:
- virtual void init_actions();
+ void init_actions() override;
};
DirectionalLight *sun = nullptr;
- virtual Sky *create(const std::map<std::string, Renderable *> &) const;
+ Sky *create(const std::map<std::string, Renderable *> &) const override;
};
private:
Color get_transmittance(const Vector3 &);
- virtual void setup_frame(Renderer &);
- virtual void finish_frame();
- virtual void render(Renderer &, Tag = Tag()) const;
+ void setup_frame(Renderer &) override;
+ void finish_frame() override;
+ void render(Renderer &, Tag = Tag()) const override;
- virtual void set_debug_name(const std::string &);
+ void set_debug_name(const std::string &) override;
};
} // namespace GL
template<typename T>
typename T::const_iterator increment(typename T::const_iterator &, const T &);
- virtual void visit(Block &);
- virtual void visit(Literal &);
- virtual void visit(VariableReference &);
- virtual void visit(MemberAccess &);
- virtual void visit(Swizzle &);
- virtual void visit(UnaryExpression &);
- virtual void visit(BinaryExpression &);
- virtual void visit(Assignment &);
- virtual void visit(TernaryExpression &);
- virtual void visit(FunctionCall &);
- virtual void visit(ExpressionStatement &);
- virtual void visit(Import &);
- virtual void visit(Precision &);
- virtual void visit(Layout &);
- virtual void visit(InterfaceLayout &);
- virtual void visit(BasicTypeDeclaration &);
- virtual void visit(ImageTypeDeclaration &);
- virtual void visit(StructDeclaration &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &);
- virtual void visit(Conditional &);
- virtual void visit(Iteration &);
- virtual void visit(Passthrough &);
- virtual void visit(Return &);
- virtual void visit(Jump &);
+ void visit(Block &) override;
+ void visit(Literal &) override;
+ void visit(VariableReference &) override;
+ void visit(MemberAccess &) override;
+ void visit(Swizzle &) override;
+ void visit(UnaryExpression &) override;
+ void visit(BinaryExpression &) override;
+ void visit(Assignment &) override;
+ void visit(TernaryExpression &) override;
+ void visit(FunctionCall &) override;
+ void visit(ExpressionStatement &) override;
+ void visit(Import &) override;
+ void visit(Precision &) override;
+ void visit(Layout &) override;
+ void visit(InterfaceLayout &) override;
+ void visit(BasicTypeDeclaration &) override;
+ void visit(ImageTypeDeclaration &) override;
+ void visit(StructDeclaration &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override;
+ void visit(Conditional &) override;
+ void visit(Iteration &) override;
+ void visit(Passthrough &) override;
+ void visit(Return &) override;
+ void visit(Jump &) override;
};
} // namespace SL
void apply(Stage &s) { s.content.visit(*this); }
private:
- virtual void visit(StructDeclaration &);
- virtual void visit(VariableDeclaration &);
+ void visit(StructDeclaration &) override;
+ void visit(VariableDeclaration &) override;
};
/** Assigns location and binding layout qualifiers to interface variables and
void bind_uniform(RefPtr<Layout> &, const std::string &, unsigned);
bool visit_uniform(const std::string &, RefPtr<Layout> &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &) { }
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override { }
};
/**
private:
NodePtr<Statement> create_conversion_statement();
- virtual void visit(Block &);
- virtual void visit(VariableReference &);
- virtual void visit(MemberAccess &);
- virtual void visit(Swizzle &);
- virtual void visit(Assignment &);
- virtual void visit(FunctionCall &);
- virtual void visit(FunctionDeclaration &);
+ void visit(Block &) override;
+ void visit(VariableReference &) override;
+ void visit(MemberAccess &) override;
+ void visit(Swizzle &) override;
+ void visit(Assignment &) override;
+ void visit(FunctionCall &) override;
+ void visit(FunctionDeclaration &) override;
};
/** Generates default precision declarations or removes precision declarations
void apply(Stage &);
private:
- virtual void visit(Block &);
- virtual void visit(Precision &);
- virtual void visit(VariableDeclaration &);
+ void visit(Block &) override;
+ void visit(Precision &) override;
+ void visit(VariableDeclaration &) override;
};
/** Base class for feature converters. */
public:
void apply(Stage &s, const Features &f) { FeatureConverter::apply(s, f); }
private:
- virtual void apply();
+ void apply() override;
- virtual void visit(Block &);
- virtual void visit(RefPtr<Expression> &);
+ void visit(Block &) override;
+ void visit(RefPtr<Expression> &) override;
bool supports_stage(Stage::Type) const;
bool supports_unified_interface_syntax() const;
- virtual void visit(VariableReference &);
- virtual void visit(MemberAccess &);
- virtual void visit(Assignment &);
+ void visit(VariableReference &) override;
+ void visit(MemberAccess &) override;
+ void visit(Assignment &) override;
bool supports_unified_sampling_functions() const;
- virtual void visit(FunctionCall &);
+ void visit(FunctionCall &) override;
bool supports_interface_blocks(const std::string &) const;
- virtual void visit(VariableDeclaration &);
+ void visit(VariableDeclaration &) override;
};
/** Converts qualifiers on variables and blocksto match a particular set of
public:
void apply(Stage &s, const Features &f) { FeatureConverter::apply(s, f); }
private:
- virtual void apply();
+ void apply() override;
bool supports_interface_layouts() const;
bool supports_stage_interface_layouts() const;
bool supports_uniform_location() const;
bool supports_binding() const;
bool supports_interface_block_location() const;
- virtual void visit(VariableDeclaration &);
+ void visit(VariableDeclaration &) override;
};
} // namespace SL
void apply(Module &, const Features &);
private:
- virtual void visit(VariableDeclaration &);
+ void visit(VariableDeclaration &) override;
};
/** Materializes implicitly declared interfaces.
private:
static std::string get_out_prefix(Stage::Type);
std::string change_prefix(const std::string &, const std::string &) const;
- virtual void visit(Block &);
+ void visit(Block &) override;
VariableDeclaration *generate_interface(VariableDeclaration &, const std::string &, const std::string &);
ExpressionStatement &insert_assignment(const std::string &, Expression *);
- virtual void visit(VariableReference &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &);
- virtual void visit(Passthrough &);
+ void visit(VariableReference &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override;
+ void visit(Passthrough &) override;
};
class LayoutDefaulter: private TraversingVisitor
void apply(Stage &);
private:
- virtual void visit(InterfaceLayout &);
+ void visit(InterfaceLayout &) override;
};
/**
void apply(Stage &);
private:
- virtual void visit(VariableReference &);
- virtual void visit(MemberAccess &);
- virtual void visit(Swizzle &);
- virtual void visit(UnaryExpression&);
- virtual void visit(BinaryExpression &);
- virtual void visit(TernaryExpression &);
- virtual void visit(FunctionCall &);
- virtual void visit(InterfaceLayout &);
- virtual void visit(VariableDeclaration &);
+ void visit(VariableReference &) override;
+ void visit(MemberAccess &) override;
+ void visit(Swizzle &) override;
+ void visit(UnaryExpression&) override;
+ void visit(BinaryExpression &) override;
+ void visit(TernaryExpression &) override;
+ void visit(FunctionCall &) override;
+ void visit(InterfaceLayout &) override;
+ void visit(VariableDeclaration &) override;
};
} // namespace SL
void apply(Stage &, const std::map<std::string, int> &);
private:
- virtual void visit(VariableDeclaration &);
+ void visit(VariableDeclaration &) override;
};
/** Finds functions which are candidates for inlining. Currently this means
std::set<FunctionDeclaration *> apply(Stage &s) { s.content.visit(*this); return inlineable; }
private:
- virtual void visit(FunctionCall &);
- virtual void visit(FunctionDeclaration &);
- virtual void visit(Conditional &);
- virtual void visit(Iteration &);
- virtual void visit(Return &);
+ void visit(FunctionCall &) override;
+ void visit(FunctionDeclaration &) override;
+ void visit(Conditional &) override;
+ void visit(Iteration &) override;
+ void visit(Return &) override;
};
/** Injects statements from one function into another. Local variables are
std::string apply(Stage &, FunctionDeclaration &, Block &, const NodeList<Statement>::iterator &, FunctionCall &);
private:
- virtual void visit(VariableReference &);
- virtual void visit(FunctionCall &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(Return &);
+ void visit(VariableReference &) override;
+ void visit(FunctionCall &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(Return &) override;
};
/** Inlines functions. Internally uses InlineableFunctionLocator to find
bool apply(Stage &);
private:
- virtual void visit(RefPtr<Expression> &);
- virtual void visit(Block &);
- virtual void visit(FunctionCall &);
- virtual void visit(FunctionDeclaration &);
- virtual void visit(Iteration &);
+ void visit(RefPtr<Expression> &) override;
+ void visit(Block &) override;
+ void visit(FunctionCall &) override;
+ void visit(FunctionDeclaration &) override;
+ void visit(Iteration &) override;
};
/** Inlines variables into expressions. Variables with trivial values (those
bool apply(Stage &);
private:
- virtual void visit(RefPtr<Expression> &);
- virtual void visit(VariableReference &);
- virtual void visit(MemberAccess &);
- virtual void visit(Swizzle &);
- virtual void visit(UnaryExpression &);
- virtual void visit(BinaryExpression &);
- virtual void visit(Assignment &);
- virtual void visit(TernaryExpression &);
- virtual void visit(FunctionCall &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(Iteration &);
+ void visit(RefPtr<Expression> &) override;
+ void visit(VariableReference &) override;
+ void visit(MemberAccess &) override;
+ void visit(Swizzle &) override;
+ void visit(UnaryExpression &) override;
+ void visit(BinaryExpression &) override;
+ void visit(Assignment &) override;
+ void visit(TernaryExpression &) override;
+ void visit(FunctionCall &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(Iteration &) override;
};
/**
bool apply(Stage &);
private:
- virtual void visit(Block &);
- virtual void visit(RefPtr<Expression> &);
- virtual void visit(VariableReference &);
+ void visit(Block &) override;
+ void visit(RefPtr<Expression> &) override;
+ void visit(VariableReference &) override;
void visit_composite(RefPtr<Expression> &);
- virtual void visit(MemberAccess &);
- virtual void visit(BinaryExpression &);
- virtual void visit(StructDeclaration &) { }
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &);
+ void visit(MemberAccess &) override;
+ void visit(BinaryExpression &) override;
+ void visit(StructDeclaration &) override { }
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override;
};
/** Replaces expressions consisting entirely of literals with the results of
void convert_to_result(const Variant &);
void set_result(const Variant &, bool = false);
- virtual void visit(RefPtr<Expression> &);
- virtual void visit(Literal &);
- virtual void visit(VariableReference &);
- virtual void visit(MemberAccess &);
- virtual void visit(Swizzle &);
- virtual void visit(UnaryExpression &);
- virtual void visit(BinaryExpression &);
- virtual void visit(Assignment &);
- virtual void visit(TernaryExpression &);
- virtual void visit(FunctionCall &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(Iteration &);
+ void visit(RefPtr<Expression> &) override;
+ void visit(Literal &) override;
+ void visit(VariableReference &) override;
+ void visit(MemberAccess &) override;
+ void visit(Swizzle &) override;
+ void visit(UnaryExpression &) override;
+ void visit(BinaryExpression &) override;
+ void visit(Assignment &) override;
+ void visit(TernaryExpression &) override;
+ void visit(FunctionCall &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(Iteration &) override;
};
/** Removes conditional statements and loops where the condition can be
private:
ConstantStatus check_constant_condition(const Expression &);
- virtual void visit(Block &);
- virtual void visit(RefPtr<Expression> &);
- virtual void visit(UnaryExpression &);
- virtual void visit(Assignment &);
- virtual void visit(TernaryExpression &);
- virtual void visit(FunctionCall &);
- virtual void visit(Conditional &);
- virtual void visit(Iteration &);
+ void visit(Block &) override;
+ void visit(RefPtr<Expression> &) override;
+ void visit(UnaryExpression &) override;
+ void visit(Assignment &) override;
+ void visit(TernaryExpression &) override;
+ void visit(FunctionCall &) override;
+ void visit(Conditional &) override;
+ void visit(Iteration &) override;
};
/** Removes code which is never executed due to flow control statements. */
virtual bool apply(Stage &);
private:
- virtual void visit(Block &);
- virtual void visit(FunctionDeclaration &);
- virtual void visit(Conditional &);
- virtual void visit(Iteration &);
- virtual void visit(Return &) { reachable = false; }
- virtual void visit(Jump &) { reachable = false; }
+ void visit(Block &) override;
+ void visit(FunctionDeclaration &) override;
+ void visit(Conditional &) override;
+ void visit(Iteration &) override;
+ void visit(Return &) override { reachable = false; }
+ void visit(Jump &) override { reachable = false; }
};
/** Removes types which are not used anywhere. */
bool apply(Stage &);
private:
- virtual void visit(RefPtr<Expression> &);
- virtual void visit(BasicTypeDeclaration &);
- virtual void visit(ImageTypeDeclaration &);
- virtual void visit(StructDeclaration &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &);
+ void visit(RefPtr<Expression> &) override;
+ void visit(BasicTypeDeclaration &) override;
+ void visit(ImageTypeDeclaration &) override;
+ void visit(StructDeclaration &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override;
};
/** Removes variable declarations with no references to them. Assignment
private:
void referenced(const Assignment::Target &, Node &);
- virtual void visit(VariableReference &);
+ void visit(VariableReference &) override;
void visit_composite(Expression &);
- virtual void visit(MemberAccess &);
- virtual void visit(Swizzle &);
- virtual void visit(UnaryExpression &);
- virtual void visit(BinaryExpression &);
- virtual void visit(Assignment &);
- virtual void visit(TernaryExpression &);
- virtual void visit(FunctionCall &);
+ void visit(MemberAccess &) override;
+ void visit(Swizzle &) override;
+ void visit(UnaryExpression &) override;
+ void visit(BinaryExpression &) override;
+ void visit(Assignment &) override;
+ void visit(TernaryExpression &) override;
+ void visit(FunctionCall &) override;
void record_assignment(const Assignment::Target &, Node &);
- virtual void visit(ExpressionStatement &);
- virtual void visit(StructDeclaration &);
- virtual void visit(VariableDeclaration &);
+ void visit(ExpressionStatement &) override;
+ void visit(StructDeclaration &) override;
+ void visit(VariableDeclaration &) override;
void merge_variables(const BlockVariableMap &);
- virtual void visit(FunctionDeclaration &);
- virtual void visit(Conditional &);
- virtual void visit(Iteration &);
+ void visit(FunctionDeclaration &) override;
+ void visit(Conditional &) override;
+ void visit(Iteration &) override;
};
/** Removes function declarations with no references to them. */
bool apply(Stage &s);
private:
- virtual void visit(FunctionCall &);
- virtual void visit(FunctionDeclaration &);
+ void visit(FunctionCall &) override;
+ void visit(FunctionDeclaration &) override;
};
} // namespace SL
void append(char);
void set_source(unsigned, unsigned);
- virtual void visit(Block &);
+ void visit(Block &) override;
void visit_expression(Expression &, const Operator *, bool);
- virtual void visit(Literal &);
- virtual void visit(VariableReference &);
- virtual void visit(MemberAccess &);
- virtual void visit(Swizzle &);
- virtual void visit(UnaryExpression &);
- virtual void visit(BinaryExpression &);
- virtual void visit(Assignment &);
- virtual void visit(TernaryExpression &);
- virtual void visit(FunctionCall &);
- virtual void visit(ExpressionStatement &);
- virtual void visit(Import &);
- virtual void visit(Precision &);
- virtual void visit(Layout &);
- virtual void visit(InterfaceLayout &);
- virtual void visit(StructDeclaration &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &);
- virtual void visit(Conditional &);
- virtual void visit(Iteration &);
- virtual void visit(Passthrough &);
- virtual void visit(Return &);
- virtual void visit(Jump &);
+ void visit(Literal &) override;
+ void visit(VariableReference &) override;
+ void visit(MemberAccess &) override;
+ void visit(Swizzle &) override;
+ void visit(UnaryExpression &) override;
+ void visit(BinaryExpression &) override;
+ void visit(Assignment &) override;
+ void visit(TernaryExpression &) override;
+ void visit(FunctionCall &) override;
+ void visit(ExpressionStatement &) override;
+ void visit(Import &) override;
+ void visit(Precision &) override;
+ void visit(Layout &) override;
+ void visit(InterfaceLayout &) override;
+ void visit(StructDeclaration &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override;
+ void visit(Conditional &) override;
+ void visit(Iteration &) override;
+ void visit(Passthrough &) override;
+ void visit(Return &) override;
+ void visit(Jump &) override;
};
} // namespace SL
void compare(Node &, Node &);
template<typename T>
T *multi_visit(T &);
- virtual void visit(Literal &);
- virtual void visit(VariableReference &);
- virtual void visit(UnaryExpression &);
- virtual void visit(BinaryExpression &);
- virtual void visit(TernaryExpression &);
- virtual void visit(FunctionCall &);
- virtual void visit(BasicTypeDeclaration &);
- virtual void visit(ImageTypeDeclaration &);
- virtual void visit(StructDeclaration &);
- virtual void visit(VariableDeclaration &);
+ void visit(Literal &) override;
+ void visit(VariableReference &) override;
+ void visit(UnaryExpression &) override;
+ void visit(BinaryExpression &) override;
+ void visit(TernaryExpression &) override;
+ void visit(FunctionCall &) override;
+ void visit(BasicTypeDeclaration &) override;
+ void visit(ImageTypeDeclaration &) override;
+ void visit(StructDeclaration &) override;
+ void visit(VariableDeclaration &) override;
};
/** Determines the number of interface locations required by a variable. */
unsigned apply(VariableDeclaration &v) { v.visit(*this); return r_count; }
private:
- virtual void visit(BasicTypeDeclaration &);
- virtual void visit(ImageTypeDeclaration &);
- virtual void visit(StructDeclaration &);
- virtual void visit(VariableDeclaration &);
+ void visit(BasicTypeDeclaration &) override;
+ void visit(ImageTypeDeclaration &) override;
+ void visit(StructDeclaration &) override;
+ void visit(VariableDeclaration &) override;
};
/** Determines the size and alignment of a variable or a type, in bytes. */
Result apply(TypeDeclaration &t) { t.visit(*this); return Result(r_size, r_alignment); }
private:
- virtual void visit(BasicTypeDeclaration &);
- virtual void visit(StructDeclaration &);
- virtual void visit(VariableDeclaration &);
+ void visit(BasicTypeDeclaration &) override;
+ void visit(StructDeclaration &) override;
+ void visit(VariableDeclaration &) override;
};
/** Collects dependencies of a function. This includes global variables,
std::set<Node *> apply(FunctionDeclaration &);
private:
- virtual void visit(VariableReference &);
- virtual void visit(FunctionCall &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &);
+ void visit(VariableReference &) override;
+ void visit(FunctionCall &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override;
};
class AssignmentCollector: private TraversingVisitor
std::set<Node *> apply(Node &);
private:
- virtual void visit(VariableReference &);
- virtual void visit(UnaryExpression &);
- virtual void visit(BinaryExpression &);
- virtual void visit(Assignment &);
+ void visit(VariableReference &) override;
+ void visit(UnaryExpression &) override;
+ void visit(BinaryExpression &) override;
+ void visit(Assignment &) override;
};
} // namespace SL
bool apply(Stage &s) { r_any_resolved = false; s.content.visit(*this); return r_any_resolved; }
private:
- virtual void enter(Block &);
+ void enter(Block &) override;
};
/** Resolves types of variables and base types of other types. */
TypeDeclaration *get_or_create_array_type(TypeDeclaration &);
TypeDeclaration *get_or_create_image_type(ImageTypeDeclaration &, const std::string &);
void resolve_type(TypeDeclaration *&, const std::string &, bool, const Layout * = nullptr);
- virtual void visit(Block &);
- virtual void visit(BasicTypeDeclaration &);
- virtual void visit(ImageTypeDeclaration &);
- virtual void visit(StructDeclaration &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &);
+ void visit(Block &) override;
+ void visit(BasicTypeDeclaration &) override;
+ void visit(ImageTypeDeclaration &) override;
+ void visit(StructDeclaration &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override;
};
/** Resolves variable references. */
bool apply(Stage &);
private:
- virtual void enter(Block &);
- virtual void visit(RefPtr<Expression> &);
+ void enter(Block &) override;
+ void visit(RefPtr<Expression> &) override;
void check_assignment_target(VariableDeclaration *);
- virtual void visit(VariableReference &);
- virtual void visit(MemberAccess &);
- virtual void visit(Swizzle &);
- virtual void visit(BinaryExpression &);
- virtual void visit(Assignment &);
+ void visit(VariableReference &) override;
+ void visit(MemberAccess &) override;
+ void visit(Swizzle &) override;
+ void visit(BinaryExpression &) override;
+ void visit(Assignment &) override;
void merge_layouts(Layout &, const Layout &);
void redeclare_builtin(VariableDeclaration &, VariableDeclaration &);
- virtual void visit(VariableDeclaration &);
+ void visit(VariableDeclaration &) override;
};
/** Resolves types and lvalueness of expressions. */
bool truncate_vector(RefPtr<Expression> &, unsigned);
void resolve(Expression &, TypeDeclaration *, bool);
- virtual void visit(Block &);
- virtual void visit(Literal &);
- virtual void visit(VariableReference &);
- virtual void visit(MemberAccess &);
- virtual void visit(Swizzle &);
- virtual void visit(UnaryExpression &);
+ void visit(Block &) override;
+ void visit(Literal &) override;
+ void visit(VariableReference &) override;
+ void visit(MemberAccess &) override;
+ void visit(Swizzle &) override;
+ void visit(UnaryExpression &) override;
void visit(BinaryExpression &, bool);
- virtual void visit(BinaryExpression &);
- virtual void visit(Assignment &);
- virtual void visit(TernaryExpression &);
+ void visit(BinaryExpression &) override;
+ void visit(Assignment &) override;
+ void visit(TernaryExpression &) override;
void visit_constructor(FunctionCall &);
- virtual void visit(FunctionCall &);
- virtual void visit(BasicTypeDeclaration &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &);
- virtual void visit(Return &);
+ void visit(FunctionCall &) override;
+ void visit(BasicTypeDeclaration &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override;
+ void visit(Return &) override;
using TraversingVisitor::visit;
};
private:
static bool can_convert_arguments(const FunctionCall &, const FunctionDeclaration &);
- virtual void visit(FunctionCall &);
- virtual void visit(FunctionDeclaration &);
+ void visit(FunctionCall &) override;
+ void visit(FunctionDeclaration &) override;
};
} // namespace SL
void write_deconstruct(Id, Id, Id *, unsigned);
Id write_construct(Id, const Id *, unsigned);
- virtual void visit(Block &);
- virtual void visit(Literal &);
- virtual void visit(VariableReference &);
+ void visit(Block &) override;
+ void visit(Literal &) override;
+ void visit(VariableReference &) override;
void generate_composite_access(TypeDeclaration &);
void visit_composite(Expression &, unsigned, TypeDeclaration &);
void visit_isolated(Expression &);
- virtual void visit(MemberAccess &);
- virtual void visit(Swizzle &);
- virtual void visit(UnaryExpression &);
- virtual void visit(BinaryExpression &);
- virtual void visit(Assignment &);
- virtual void visit(TernaryExpression &);
- virtual void visit(FunctionCall &);
+ void visit(MemberAccess &) override;
+ void visit(Swizzle &) override;
+ void visit(UnaryExpression &) override;
+ void visit(BinaryExpression &) override;
+ void visit(Assignment &) override;
+ void visit(TernaryExpression &) override;
+ void visit(FunctionCall &) override;
void visit_constructor(FunctionCall &, const std::vector<Id> &, bool);
void visit_builtin_matrix_comp_mult(FunctionCall &, const std::vector<Id> &);
void visit_builtin_texture_query(FunctionCall &, const std::vector<Id> &);
void visit_builtin_texture_fetch(FunctionCall &, const std::vector<Id> &);
void visit_builtin_texture_store(FunctionCall &, const std::vector<Id> &);
void visit_builtin_interpolate(FunctionCall &, const std::vector<Id> &);
- virtual void visit(ExpressionStatement &);
- virtual void visit(InterfaceLayout &);
+ void visit(ExpressionStatement &) override;
+ void visit(InterfaceLayout &) override;
bool check_duplicate_type(TypeDeclaration &);
bool check_standard_type(BasicTypeDeclaration &);
- virtual void visit(BasicTypeDeclaration &);
- virtual void visit(ImageTypeDeclaration &);
- virtual void visit(StructDeclaration &);
- virtual void visit(VariableDeclaration &);
+ void visit(BasicTypeDeclaration &) override;
+ void visit(ImageTypeDeclaration &) override;
+ void visit(StructDeclaration &) override;
+ void visit(VariableDeclaration &) override;
void visit_entry_point(FunctionDeclaration &, Id);
- virtual void visit(FunctionDeclaration &);
- virtual void visit(Conditional &);
- virtual void visit(Iteration &);
- virtual void visit(Return &);
- virtual void visit(Jump &);
+ void visit(FunctionDeclaration &) override;
+ void visit(Conditional &) override;
+ void visit(Iteration &) override;
+ void visit(Return &) override;
+ void visit(Jump &) override;
};
} // namespace SL
struct Statement: Node
{
- virtual Statement *clone() const = 0;
+ Statement *clone() const override = 0;
};
struct Block: Node
Block() = default;
Block(const Block &);
- virtual Block *clone() const { return new Block(*this); }
- virtual void visit(NodeVisitor &);
+ Block *clone() const override { return new Block(*this); }
+ void visit(NodeVisitor &) override;
};
struct Expression: Node
TypeDeclaration *type = nullptr;
bool lvalue = false;
- virtual Expression *clone() const = 0;
+ Expression *clone() const override = 0;
};
struct Literal: Expression
std::string token;
Variant value;
- virtual Literal *clone() const { return new Literal(*this); }
- virtual void visit(NodeVisitor &);
+ Literal *clone() const override { return new Literal(*this); }
+ void visit(NodeVisitor &) override;
};
struct VariableReference: Expression
VariableReference() = default;
VariableReference(const VariableReference &);
- virtual VariableReference *clone() const { return new VariableReference(*this); }
- virtual void visit(NodeVisitor &);
+ VariableReference *clone() const override { return new VariableReference(*this); }
+ void visit(NodeVisitor &) override;
};
struct MemberAccess: Expression
MemberAccess() = default;
MemberAccess(const MemberAccess &);
- virtual MemberAccess *clone() const { return new MemberAccess(*this); }
- virtual void visit(NodeVisitor &);
+ MemberAccess *clone() const override { return new MemberAccess(*this); }
+ void visit(NodeVisitor &) override;
};
struct Swizzle: Expression
unsigned count = 0;
std::uint8_t components[4] = { 0, 0, 0, 0 };
- virtual Swizzle *clone() const { return new Swizzle(*this); }
- virtual void visit(NodeVisitor &);
+ Swizzle *clone() const override { return new Swizzle(*this); }
+ void visit(NodeVisitor &) override;
};
struct UnaryExpression: Expression
{
NodePtr<Expression> expression;
- virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
- virtual void visit(NodeVisitor &);
+ UnaryExpression *clone() const override { return new UnaryExpression(*this); }
+ void visit(NodeVisitor &) override;
};
struct BinaryExpression: Expression
NodePtr<Expression> left;
NodePtr<Expression> right;
- virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
- virtual void visit(NodeVisitor &);
+ BinaryExpression *clone() const override { return new BinaryExpression(*this); }
+ void visit(NodeVisitor &) override;
};
struct Assignment: BinaryExpression
Assignment() = default;
Assignment(const Assignment &);
- virtual Assignment *clone() const { return new Assignment(*this); }
- virtual void visit(NodeVisitor &);
+ Assignment *clone() const override { return new Assignment(*this); }
+ void visit(NodeVisitor &) override;
};
struct TernaryExpression: Expression
NodePtr<Expression> true_expr;
NodePtr<Expression> false_expr;
- virtual TernaryExpression *clone() const { return new TernaryExpression(*this); }
- virtual void visit(NodeVisitor &);
+ TernaryExpression *clone() const override { return new TernaryExpression(*this); }
+ void visit(NodeVisitor &) override;
};
struct FunctionCall: Expression
FunctionCall() = default;
FunctionCall(const FunctionCall &);
- virtual FunctionCall *clone() const { return new FunctionCall(*this); }
- virtual void visit(NodeVisitor &);
+ FunctionCall *clone() const override { return new FunctionCall(*this); }
+ void visit(NodeVisitor &) override;
};
struct ExpressionStatement: Statement
{
NodePtr<Expression> expression;
- virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
- virtual void visit(NodeVisitor &);
+ ExpressionStatement *clone() const override { return new ExpressionStatement(*this); }
+ void visit(NodeVisitor &) override;
};
struct Import: Statement
{
std::string module;
- virtual Import *clone() const { return new Import(*this); }
- virtual void visit(NodeVisitor &);
+ Import *clone() const override { return new Import(*this); }
+ void visit(NodeVisitor &) override;
};
struct Precision: Statement
std::string precision;
std::string type;
- virtual Precision *clone() const { return new Precision(*this); }
- virtual void visit(NodeVisitor &);
+ Precision *clone() const override { return new Precision(*this); }
+ void visit(NodeVisitor &) override;
};
struct Layout: Node
std::vector<Qualifier> qualifiers;
- virtual Layout *clone() const { return new Layout(*this); }
- virtual void visit(NodeVisitor &);
+ Layout *clone() const override { return new Layout(*this); }
+ void visit(NodeVisitor &) override;
};
struct InterfaceLayout: Statement
std::string interface;
Layout layout;
- virtual InterfaceLayout *clone() const { return new InterfaceLayout(*this); }
- virtual void visit(NodeVisitor &);
+ InterfaceLayout *clone() const override { return new InterfaceLayout(*this); }
+ void visit(NodeVisitor &) override;
};
struct TypeDeclaration: Statement
{
std::string name;
- virtual TypeDeclaration *clone() const = 0;
+ TypeDeclaration *clone() const override = 0;
};
struct BasicTypeDeclaration: TypeDeclaration
BasicTypeDeclaration() = default;
BasicTypeDeclaration(const BasicTypeDeclaration &);
- virtual BasicTypeDeclaration *clone() const { return new BasicTypeDeclaration(*this); }
- virtual void visit(NodeVisitor &);
+ BasicTypeDeclaration *clone() const override { return new BasicTypeDeclaration(*this); }
+ void visit(NodeVisitor &) override;
};
struct ImageTypeDeclaration: TypeDeclaration
TypeDeclaration *base_type = nullptr;
ImageTypeDeclaration *base_image = nullptr;
- virtual ImageTypeDeclaration *clone() const { return new ImageTypeDeclaration(*this); }
- virtual void visit(NodeVisitor &);
+ ImageTypeDeclaration *clone() const override { return new ImageTypeDeclaration(*this); }
+ void visit(NodeVisitor &) override;
};
struct StructDeclaration: TypeDeclaration
StructDeclaration();
StructDeclaration(const StructDeclaration &);
- virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
- virtual void visit(NodeVisitor &);
+ StructDeclaration *clone() const override { return new StructDeclaration(*this); }
+ void visit(NodeVisitor &) override;
};
struct VariableDeclaration: Statement
VariableDeclaration() = default;
VariableDeclaration(const VariableDeclaration &);
- ~VariableDeclaration();
+ ~VariableDeclaration() override;
- virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
- virtual void visit(NodeVisitor &);
+ VariableDeclaration *clone() const override { return new VariableDeclaration(*this); }
+ void visit(NodeVisitor &) override;
};
struct FunctionDeclaration: Statement
FunctionDeclaration() = default;
FunctionDeclaration(const FunctionDeclaration &);
- virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
- virtual void visit(NodeVisitor &);
+ FunctionDeclaration *clone() const override { return new FunctionDeclaration(*this); }
+ void visit(NodeVisitor &) override;
};
struct Conditional: Statement
Block body;
Block else_body;
- virtual Conditional *clone() const { return new Conditional(*this); }
- virtual void visit(NodeVisitor &);
+ Conditional *clone() const override { return new Conditional(*this); }
+ void visit(NodeVisitor &) override;
};
struct Iteration: Statement
NodePtr<Expression> loop_expression;
Block body;
- virtual Iteration *clone() const { return new Iteration(*this); }
- virtual void visit(NodeVisitor &);
+ Iteration *clone() const override { return new Iteration(*this); }
+ void visit(NodeVisitor &) override;
};
struct Passthrough: Statement
{
NodePtr<Expression> subscript;
- virtual Passthrough *clone() const { return new Passthrough(*this); }
- virtual void visit(NodeVisitor &);
+ Passthrough *clone() const override { return new Passthrough(*this); }
+ void visit(NodeVisitor &) override;
};
struct Return: Statement
{
NodePtr<Expression> expression;
- virtual Return *clone() const { return new Return(*this); }
- virtual void visit(NodeVisitor &);
+ Return *clone() const override { return new Return(*this); }
+ void visit(NodeVisitor &) override;
};
struct Jump: Statement
{
std::string keyword;
- virtual Jump *clone() const { return new Jump(*this); }
- virtual void visit(NodeVisitor &);
+ Jump *clone() const override { return new Jump(*this); }
+ void visit(NodeVisitor &) override;
};
struct Stage
private:
static const char *describe_variable(ScopeType);
- virtual void visit(Layout &);
- virtual void visit(InterfaceLayout &);
- virtual void visit(BasicTypeDeclaration &);
- virtual void visit(ImageTypeDeclaration &);
- virtual void visit(StructDeclaration &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &);
+ void visit(Layout &) override;
+ void visit(InterfaceLayout &) override;
+ void visit(BasicTypeDeclaration &) override;
+ void visit(ImageTypeDeclaration &) override;
+ void visit(StructDeclaration &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override;
};
/** Verifies that identifiers are unique or, in the case of functions, are
void record_definition(const std::string &, Statement &);
virtual void visit(TypeDeclaration &);
- virtual void visit(BasicTypeDeclaration &t) { visit(static_cast<TypeDeclaration &>(t)); }
- virtual void visit(ImageTypeDeclaration &t) { visit(static_cast<TypeDeclaration &>(t)); }
- virtual void visit(StructDeclaration &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &);
+ void visit(BasicTypeDeclaration &t) override { visit(static_cast<TypeDeclaration &>(t)); }
+ void visit(ImageTypeDeclaration &t) override { visit(static_cast<TypeDeclaration &>(t)); }
+ void visit(StructDeclaration &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override;
using Validator::visit;
};
void apply(Stage &s) { stage = &s; s.content.visit(*this); }
private:
- virtual void visit(BasicTypeDeclaration &);
- virtual void visit(ImageTypeDeclaration &);
- virtual void visit(VariableReference &);
- virtual void visit(MemberAccess &);
- virtual void visit(FunctionCall &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &);
+ void visit(BasicTypeDeclaration &) override;
+ void visit(ImageTypeDeclaration &) override;
+ void visit(VariableReference &) override;
+ void visit(MemberAccess &) override;
+ void visit(FunctionCall &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override;
};
/** Verifies that expressions are valid. In most cases an invalid expression
void apply(Stage &s) { stage = &s; s.content.visit(*this); }
private:
- virtual void visit(VariableReference &);
- virtual void visit(Swizzle &);
- virtual void visit(UnaryExpression &);
- virtual void visit(BinaryExpression &);
- virtual void visit(Assignment &);
- virtual void visit(TernaryExpression &);
- virtual void visit(StructDeclaration &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &);
- virtual void visit(Conditional &);
- virtual void visit(Iteration &);
- virtual void visit(Return &);
+ void visit(VariableReference &) override;
+ void visit(Swizzle &) override;
+ void visit(UnaryExpression &) override;
+ void visit(BinaryExpression &) override;
+ void visit(Assignment &) override;
+ void visit(TernaryExpression &) override;
+ void visit(StructDeclaration &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override;
+ void visit(Conditional &) override;
+ void visit(Iteration &) override;
+ void visit(Return &) override;
};
/** Verifies flow control constructs. Functions returning non-void must have
void apply(Stage &s) { stage = &s; s.content.visit(*this); }
private:
- virtual void visit(Block &);
- virtual void visit(FunctionDeclaration &);
- virtual void visit(Conditional &);
- virtual void visit(Iteration &);
- virtual void visit(Return &) { reachable = false; }
- virtual void visit(Jump &) { reachable = false; }
+ void visit(Block &) override;
+ void visit(FunctionDeclaration &) override;
+ void visit(Conditional &) override;
+ void visit(Iteration &) override;
+ void visit(Return &) override { reachable = false; }
+ void visit(Jump &) override { reachable = false; }
};
/** Verifies that stage input and output interfaces are valid. Linked
void apply(Stage &s) { stage = &s; s.content.visit(*this); }
private:
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &) { }
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override { }
};
/** Verifies that uniform interfaces are valid across the entire module.
private:
void check_uniform(const Uniform &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &) { }
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override { }
};
} // namespace SL
public:
virtual void enter(Block &) { }
- virtual void visit(Block &);
+ void visit(Block &) override;
virtual void visit(RefPtr<Expression> &);
- virtual void visit(MemberAccess &);
- virtual void visit(Swizzle &);
- virtual void visit(UnaryExpression &);
- virtual void visit(BinaryExpression &);
- virtual void visit(Assignment &);
- virtual void visit(TernaryExpression &);
- virtual void visit(FunctionCall &);
- virtual void visit(ExpressionStatement &);
- virtual void visit(InterfaceLayout &);
- virtual void visit(StructDeclaration &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &);
- virtual void visit(Conditional &);
- virtual void visit(Iteration &);
- virtual void visit(Passthrough &);
- virtual void visit(Return &);
+ void visit(MemberAccess &) override;
+ void visit(Swizzle &) override;
+ void visit(UnaryExpression &) override;
+ void visit(BinaryExpression &) override;
+ void visit(Assignment &) override;
+ void visit(TernaryExpression &) override;
+ void visit(FunctionCall &) override;
+ void visit(ExpressionStatement &) override;
+ void visit(InterfaceLayout &) override;
+ void visit(StructDeclaration &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override;
+ void visit(Conditional &) override;
+ void visit(Iteration &) override;
+ void visit(Passthrough &) override;
+ void visit(Return &) override;
using NodeVisitor::visit;
};
template<typename T>
void remove_from_map(std::map<std::string, T *> &, const std::string &, T &);
- virtual void visit(Block &);
+ void visit(Block &) override;
void visit(TypeDeclaration &);
- virtual void visit(BasicTypeDeclaration &t) { visit(static_cast<TypeDeclaration &>(t)); }
- virtual void visit(ImageTypeDeclaration &t) { visit(static_cast<TypeDeclaration &>(t)); }
- virtual void visit(StructDeclaration &);
- virtual void visit(VariableDeclaration &);
- virtual void visit(FunctionDeclaration &);
- virtual void visit(Iteration &);
+ void visit(BasicTypeDeclaration &t) override { visit(static_cast<TypeDeclaration &>(t)); }
+ void visit(ImageTypeDeclaration &t) override { visit(static_cast<TypeDeclaration &>(t)); }
+ void visit(StructDeclaration &) override;
+ void visit(VariableDeclaration &) override;
+ void visit(FunctionDeclaration &) override;
+ void visit(Iteration &) override;
using TraversingVisitor::visit;
};
void apply(Stage &, Node &, const std::set<Node *> &);
private:
- virtual void visit(Block &);
+ void visit(Block &) override;
};
} // namespace SL
Loader(BasicMaterial &, Collection &);
private:
- virtual void init_actions();
+ void init_actions() override;
};
private:
BasicMaterial();
protected:
- virtual void fill_program_info(std::string &, std::map<std::string, int> &) const;
+ void fill_program_info(std::string &, std::map<std::string, int> &) const override;
public:
- virtual const Tag *get_texture_tags() const { return texture_tags; }
- virtual const Texture *get_texture(Tag) const;
+ const Tag *get_texture_tags() const override { return texture_tags; }
+ const Texture *get_texture(Tag) const override;
void set_diffuse(const Color &);
void set_diffuse_map(const Texture *);
Loader(DirectionalLight &);
private:
- virtual void init_actions();
+ void init_actions() override;
void direction(float, float, float);
};
public:
/** Sets the light's direction from a matrix. The negative Z axis is used
as the direction. Other axes and translation are ignored. */
- virtual void set_matrix(const Matrix &);
+ void set_matrix(const Matrix &) override;
void set_direction(const Vector3 &);
void set_transmittance(const Color &);
protected:
- virtual void update_shader_data(ProgramData &, const std::string &) const;
+ void update_shader_data(ProgramData &, const std::string &) const override;
};
} // namespace GL
protected:
Loader(Light &);
- virtual void init_actions();
+ void init_actions() override;
private:
void color(float, float, float);
GenericLoader(Collection &c): DynamicObjectLoader<Light>(&c) { }
protected:
- virtual const TypeRegistry &get_type_registry() const { return Light::get_light_registry(); }
+ const TypeRegistry &get_type_registry() const override { return Light::get_light_registry(); }
};
protected:
Light() = default;
public:
- virtual ~Light() = default;
+ ~Light() override = default;
/** Sets the color of the light. */
void set_color(const Color &);
Loader(Lighting &, Collection &);
private:
- virtual void init_actions();
+ void init_actions() override;
void ambient(float, float, float);
void fog_color(float, float, float);
protected:
Loader(Material &, Collection &);
- virtual void init_actions();
+ void init_actions() override;
private:
void alpha_cutoff(float);
GenericLoader(Collection &c): DynamicObjectLoader<Material>(&c) { }
protected:
- virtual const TypeRegistry &get_type_registry() const { return get_material_registry(); }
+ const TypeRegistry &get_type_registry() const override { return get_material_registry(); }
};
protected:
Loader(PbrMaterial &, Collection &);
private:
- virtual void init_actions();
+ void init_actions() override;
};
private:
static const Texture2D &get_or_create_fresnel_lookup();
protected:
- virtual void fill_program_info(std::string &, std::map<std::string, int> &) const;
+ void fill_program_info(std::string &, std::map<std::string, int> &) const override;
public:
- virtual const Tag *get_texture_tags() const { return texture_tags; }
- virtual const Texture *get_texture(Tag) const;
- virtual const Sampler *get_sampler(Tag) const;
+ const Tag *get_texture_tags() const override { return texture_tags; }
+ const Texture *get_texture(Tag) const override;
+ const Sampler *get_sampler(Tag) const override;
void set_base_color(const Color &);
void set_base_color_map(const Texture *);
Loader(PointLight &);
private:
- virtual void init_actions();
+ void init_actions() override;
void attenuation(float, float, float);
void position(float, float, float);
public:
/** Sets the light's position from a matrix. Only the translation part is
used. */
- virtual void set_matrix(const Matrix &);
+ void set_matrix(const Matrix &) override;
void set_position(const Vector3 &);
const Vector3 &get_position();
const float *get_attenuation() const { return attenuation; }
protected:
- virtual void update_shader_data(ProgramData &, const std::string &) const;
+ void update_shader_data(ProgramData &, const std::string &) const override;
};
} // namespace GL
public:
Loader(RenderMethod &, Collection &);
private:
- virtual void init_actions();
+ void init_actions() override;
public:
void set_inline_base_name(const std::string &);
private:
- virtual void finish();
+ void finish() override;
void blend();
void blend_factors(BlendFactor, BlendFactor);
Loader(SplatMaterial &, Collection &);
private:
- virtual void init_actions();
- virtual void finish();
+ void init_actions() override;
+ void finish() override;
void map_storage(MapArray SplatMaterial::*, PixelFormat, unsigned, unsigned);
void sub();
Loader(SubMaterial &);
private:
- virtual void init_actions();
+ void init_actions() override;
void base_color(float, float, float);
void emission(float, float, float);
public:
SplatMaterial();
- ~SplatMaterial();
+ ~SplatMaterial() override;
protected:
- virtual void fill_program_info(std::string &, std::map<std::string, int> &) const;
+ void fill_program_info(std::string &, std::map<std::string, int> &) const override;
public:
- virtual const Tag *get_texture_tags() const { return texture_tags; }
- virtual const Texture *get_texture(Tag) const;
- virtual const Sampler *get_sampler(Tag) const;
+ const Tag *get_texture_tags() const override { return texture_tags; }
+ const Texture *get_texture(Tag) const override;
+ const Sampler *get_sampler(Tag) const override;
private:
void set_sub_uniforms(unsigned);
void upload_sub_map(DataFile::Collection &, unsigned, SubMap SubMaterial::*, MapArray &, const char *);
public:
- virtual void set_debug_name(const std::string &);
+ void set_debug_name(const std::string &) override;
private:
void set_array_debug_names();
};
public:
Loader(Technique &, Collection &);
private:
- virtual void init_actions();
+ void init_actions() override;
public:
void set_inline_base_name(const std::string &);
Loader(UnlitMaterial &, Collection &);
private:
- virtual void init_actions();
+ void init_actions() override;
void texture(const std::string &);
};
UnlitMaterial();
protected:
- virtual void fill_program_info(std::string &, std::map<std::string, int> &) const;
+ void fill_program_info(std::string &, std::map<std::string, int> &) const override;
public:
- virtual const Tag *get_texture_tags() const { return texture_tags; }
- virtual const Texture *get_texture(Tag) const;
+ const Tag *get_texture_tags() const override { return texture_tags; }
+ const Texture *get_texture(Tag) const override;
void set_texture(const Texture *);
void set_color(const Color &);
const Vector3 &get_look_direction() const { return look_dir; }
const Vector3 &get_up_direction() const { return up_dir; }
- virtual void set_matrix(const Matrix &m) { set_object_matrix(m); }
+ void set_matrix(const Matrix &m) override { set_object_matrix(m); }
/** Sets the position and orientation of the camera from an object matrix. */
void set_object_matrix(const Matrix &);
Loader(InstanceArrayBase &);
private:
- virtual void init_actions();
+ void init_actions() override;
protected:
virtual void instance() = 0;
protected:
InstanceArrayBase(const Object &, std::size_t);
- ~InstanceArrayBase();
+ ~InstanceArrayBase() override;
private:
void add_block(std::size_t);
public:
std::size_t size() const { return instance_count; }
- virtual void render(Renderer &, Tag) const;
+ void render(Renderer &, Tag) const override;
};
template<typename T, typename A>
public:
InstanceArray(const Object &o): InstanceArrayBase(o, sizeof(Instance)) { }
- ~InstanceArray() { destroy_all<T>(); }
+ ~InstanceArray() override { destroy_all<T>(); }
T &append() { return *create<Instance>(*this); }
void remove(T &obj) { destroy(&obj); }
public:
Loader(Object &, Collection &);
private:
- virtual void finish();
+ void finish() override;
void bounding_sphere_hint(float, float, float, float);
void level_of_detail(unsigned);
Object(const Mesh *, const Technique *);
Object(const Object &);
Object(Object &&);
- ~Object();
+ ~Object() override;
private:
LevelOfDetail &get_lod(unsigned, const char *);
const Technique *get_technique(unsigned = 0) const;
unsigned get_n_lods() const { return lods.size(); }
- virtual const Matrix *get_matrix() const { return &identity_matrix; }
- virtual const Geometry::BoundingSphere<float, 3> *get_bounding_sphere() const { return &bounding_sphere; }
+ const Matrix *get_matrix() const override { return &identity_matrix; }
+ const Geometry::BoundingSphere<float, 3> *get_bounding_sphere() const override { return &bounding_sphere; }
- virtual void render(Renderer &, Tag = Tag()) const;
+ void render(Renderer &, Tag = Tag()) const override;
/** Renders an instance of the object. The instance's hook functions are
called before and after drawing the mesh. */
private:
const RenderMethod *get_method(Tag, unsigned) const;
- virtual void resource_loaded(Resource &);
- virtual void resource_removed(Resource &);
+ void resource_loaded(Resource &) override;
+ void resource_removed(Resource &) override;
};
} // namespace GL
const Object &get_object() const { return object; }
- virtual const Geometry::BoundingSphere<float, 3> *get_bounding_sphere() const { return object.get_bounding_sphere(); }
+ const Geometry::BoundingSphere<float, 3> *get_bounding_sphere() const override { return object.get_bounding_sphere(); }
- virtual void render(Renderer &, Tag = Tag()) const;
+ void render(Renderer &, Tag = Tag()) const override;
/** Hook function, called from Object just before rendering the mesh.
Renderer state will have been pushed before this is called. */
public:
OccludedScene();
- virtual void add(Renderable &);
- virtual void remove(Renderable &);
+ void add(Renderable &) override;
+ void remove(Renderable &) override;
private:
void populate_cache() const;
public:
- virtual void setup_frame(Renderer &);
- virtual void finish_frame();
+ void setup_frame(Renderer &) override;
+ void finish_frame() override;
- virtual void render(Renderer &, Tag = Tag()) const;
+ void render(Renderer &, Tag = Tag()) const override;
};
} // namespace GL
const Texture2D &get_target_texture(FrameAttachment a) const { return target.get_target_texture(a); }
private:
- virtual const Framebuffer &get_target() const { return target.get_framebuffer(); }
+ const Framebuffer &get_target() const override { return target.get_framebuffer(); }
};
} // namespace GL
std::vector<Renderable *> content;
public:
- virtual void add(Renderable &);
- virtual void remove(Renderable &);
+ void add(Renderable &) override;
+ void remove(Renderable &) override;
void prepend(Renderable &);
void insert(unsigned, Renderable &);
void insert_after(Renderable &, Renderable &);
- virtual void setup_frame(Renderer &);
- virtual void finish_frame();
+ void setup_frame(Renderer &) override;
+ void finish_frame() override;
- virtual void render(Renderer &, Tag = Tag()) const;
+ void render(Renderer &, Tag = Tag()) const override;
};
} // namespace GL
public:
/* Reimplement to clear ambiguity between Renderable and Placeable. This
overrides both base classes' implementations. */
- virtual const Matrix *get_matrix() const { return &matrix; }
+ const Matrix *get_matrix() const override { return &matrix; }
};
} // namespace GL
GenericLoader(DataFile::Collection &c): DynamicObjectLoader<Scene>(&c) { }
protected:
- virtual const TypeRegistry &get_type_registry() const { return get_scene_registry(); }
+ const TypeRegistry &get_type_registry() const override { return get_scene_registry(); }
};
protected:
Scene() = default;
public:
- virtual ~Scene() = default;
+ ~Scene() override = default;
virtual void add(Renderable &) = 0;
virtual void remove(Renderable &) = 0;
public:
Sequence() = default;
Sequence(unsigned, unsigned, const FrameFormat &);
- ~Sequence();
+ ~Sequence() override;
unsigned get_width() const { return width; }
unsigned get_height() const { return height; }
void add_owned(T *p)
{ owned_data.push_back({ p, [](void *ptr){ delete static_cast<T *>(ptr); } }); }
- virtual void setup_frame(Renderer &);
- virtual void finish_frame();
+ void setup_frame(Renderer &) override;
+ void finish_frame() override;
- virtual void render(Renderer &, Tag tag = Tag()) const;
+ void render(Renderer &, Tag tag = Tag()) const override;
void set_debug_name(const std::string &);
};
std::vector<Renderable *> content;
public:
- virtual void add(Renderable &);
- virtual void remove(Renderable &);
+ void add(Renderable &) override;
+ void remove(Renderable &) override;
- virtual void setup_frame(Renderer &);
- virtual void finish_frame();
+ void setup_frame(Renderer &) override;
+ void finish_frame() override;
- virtual void render(Renderer &, Tag = Tag()) const;
+ void render(Renderer &, Tag = Tag()) const override;
};
} // namespace GL
void set(Renderable *);
Renderable *get() const { return content; }
- virtual const Matrix *get_matrix() const;
- virtual const Geometry::BoundingSphere<float, 3> *get_bounding_sphere() const;
- virtual void setup_frame(Renderer &);
- virtual void finish_frame();
- virtual void render(Renderer &, Tag) const;
+ const Matrix *get_matrix() const override;
+ const Geometry::BoundingSphere<float, 3> *get_bounding_sphere() const override;
+ void setup_frame(Renderer &) override;
+ void finish_frame() override;
+ void render(Renderer &, Tag) const override;
};
} // namespace GL
float get_width() const { return width; }
- virtual void setup_render(Renderer &, Tag) const;
+ void setup_render(Renderer &, Tag) const override;
DEPRECATED operator const Object &() const { return object; }
};
WindowView(Graphics::Window &);
Graphics::Window &get_window() { return window; }
- virtual unsigned get_width() const { return window.get_width(); }
- virtual unsigned get_height() const { return window.get_height(); }
+ unsigned get_width() const override { return window.get_width(); }
+ unsigned get_height() const override { return window.get_height(); }
using View::render;
mutable std::map<const Camera *, std::vector<SortedRenderable> > sorted_cache;
public:
- virtual void add(Renderable &);
- virtual void remove(Renderable &);
+ void add(Renderable &) override;
+ void remove(Renderable &) override;
/// Sets the sort order. Default is back to front.
void set_order(SortOrder);
/// Sets the reference point for sorting. Default is furthest from camera.
void set_reference(DepthReference);
- virtual void setup_frame(Renderer &);
- virtual void finish_frame();
+ void setup_frame(Renderer &) override;
+ void finish_frame() override;
- virtual void render(Renderer &, Tag = Tag()) const;
+ void render(Renderer &, Tag = Tag()) const override;
};
} // namespace GL
LoadingThread();
private:
- virtual void main();
+ void main() override;
ManagedResource *front(std::deque<ManagedResource *> &);
public:
Resources(bool = true);
- virtual ~Resources();
+ ~Resources() override;
static Resources &get_global();
static const DataFile::CollectionSource &get_builtins();
public:
GlslCompiler(int, char **);
- virtual int main();
+ int main() override;
};
using namespace std;
public:
~Viewer();
- virtual int main();
+ int main() override;
private:
- virtual void tick();
+ void tick() override;
void button_press(unsigned);
void button_release(unsigned);
projects / libs / gl.git / commitdiff