program_object.h

Go to the documentation of this file.

/*
**  ClanLib SDK
**  Copyright (c) 1997-2011 The ClanLib Team
**
**  This software is provided 'as-is', without any express or implied
**  warranty.  In no event will the authors be held liable for any damages
**  arising from the use of this software.
**
**  Permission is granted to anyone to use this software for any purpose,
**  including commercial applications, and to alter it and redistribute it
**  freely, subject to the following restrictions:
**
**  1. The origin of this software must not be misrepresented; you must not
**     claim that you wrote the original software. If you use this software
**     in a product, an acknowledgment in the product documentation would be
**     appreciated but is not required.
**  2. Altered source versions must be plainly marked as such, and must not be
**     misrepresented as being the original software.
**  3. This notice may not be removed or altered from any source distribution.
**
**  Note: Some of the libraries ClanLib may link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
**    Harry Storbacka
**    Kenneth Gangstoe
*/


#pragma once

#include "../api_display.h"
#include "../../Core/System/sharedptr.h"
#include "../../Core/Text/string_types.h"
#include "../../Core/IOData/virtual_directory.h"
#include "graphic_context.h"

class CL_ShaderObject;
class CL_ProgramAttribute;
class CL_ProgramUniform;
class CL_ProgramObject_Impl;
class CL_GraphicContext;
class CL_GraphicContextProvider;
class CL_ResourceManager;
class CL_ProgramObjectProvider;

class CL_API_DISPLAY CL_ProgramObject
{

public:
        CL_ProgramObject();

        CL_ProgramObject(CL_GraphicContext &gc);

        CL_ProgramObject(CL_GraphicContextProvider *gc_provider);

        CL_ProgramObject(CL_ProgramObjectProvider *provider);

        static CL_ProgramObject load(CL_GraphicContext &gc, const CL_StringRef &resource_id, CL_ResourceManager *resman);

        static CL_ProgramObject load(CL_GraphicContext &gc, const CL_StringRef &vertex_fullname, const CL_StringRef &fragment_fullname);

        static CL_ProgramObject load(CL_GraphicContext &gc, const CL_StringRef &vertex_fullname, const CL_StringRef &geometry_fullname, const CL_StringRef &fragment_fullname);

        static CL_ProgramObject load(CL_GraphicContext &gc, const CL_StringRef &vertex_filename, const CL_StringRef &fragment_filename, const CL_VirtualDirectory &directory);

        static CL_ProgramObject load(CL_GraphicContext &gc, const CL_StringRef &vertex_filename, const CL_StringRef &geometry_filename, const CL_StringRef &fragment_filename, const CL_VirtualDirectory &directory);

        static CL_ProgramObject load(CL_GraphicContext &gc, CL_IODevice &vertex_file, CL_IODevice &fragment_file);

        static CL_ProgramObject load(CL_GraphicContext &gc, CL_IODevice &vertex_file, CL_IODevice &geometry_file, CL_IODevice &fragment_file);

        static CL_ProgramObject load(CL_GraphicContext &gc, const CL_StringRef &fragment_fullname);

        static CL_ProgramObject load(CL_GraphicContext &gc, const CL_StringRef &fragment_filename, const CL_VirtualDirectory &directory);

        static CL_ProgramObject load(CL_GraphicContext &gc, CL_IODevice &fragment_file);

        static CL_ProgramObject load_and_link(CL_GraphicContext &gc, const CL_StringRef &vertex_fullname, const CL_StringRef &fragment_fullname);

        static CL_ProgramObject load_and_link(CL_GraphicContext &gc, const CL_StringRef &vertex_fullname, const CL_StringRef &geometry_fullname, const CL_StringRef &fragment_fullname);

        static CL_ProgramObject load_and_link(CL_GraphicContext &gc, const CL_StringRef &vertex_filename, const CL_StringRef &fragment_filename, const CL_VirtualDirectory &directory);

        static CL_ProgramObject load_and_link(CL_GraphicContext &gc, const CL_StringRef &vertex_filename, const CL_StringRef &geometry_filename, const CL_StringRef &fragment_filename, const CL_VirtualDirectory &directory);

        static CL_ProgramObject load_and_link(CL_GraphicContext &gc, CL_IODevice &vertex_file, CL_IODevice &fragment_file);

        static CL_ProgramObject load_and_link(CL_GraphicContext &gc, CL_IODevice &vertex_file, CL_IODevice &geometry_file, CL_IODevice &fragment_file);

        static CL_ProgramObject load_and_link(CL_GraphicContext &gc, const CL_StringRef &fragment_fullname);

        static CL_ProgramObject load_and_link(CL_GraphicContext &gc, const CL_StringRef &fragment_filename, const CL_VirtualDirectory &directory);

        static CL_ProgramObject load_and_link(CL_GraphicContext &gc, CL_IODevice &fragment_file);

        virtual ~CL_ProgramObject();


public:
        bool is_null() const { return impl.is_null(); }

        void throw_if_null() const;

        CL_ProgramObjectProvider *get_provider() const;

        unsigned int get_handle() const;

        std::vector<CL_ShaderObject> get_shaders() const;

        CL_String get_info_log() const;

        int get_attribute_count() const;

        std::vector<CL_ProgramAttribute> get_attributes() const;

        int get_attribute_location(const CL_StringRef &name) const;

        int get_uniform_count() const;

        std::vector<CL_ProgramUniform> get_uniforms() const;

        int get_uniform_location(const CL_StringRef &name) const;


public:
        bool operator==(const CL_ProgramObject &other) const;

        void attach(const CL_ShaderObject &obj);

        void detach(const CL_ShaderObject &obj);


        void bind_attribute_location(int index, const CL_StringRef &name);


        bool link();


        bool validate();

        void set_uniform1i(const CL_StringRef &name, int value_a);

        void set_uniform2i(const CL_StringRef &name, int value_a, int value_b);

        void set_uniform3i(const CL_StringRef &name, int value_a, int value_b, int value_c);

        void set_uniform4i(const CL_StringRef &name, int value_a, int value_b, int value_c, int value_d);

        void set_uniformiv(const CL_StringRef &name, int size, int count, int *data);

        void set_uniform2i(const CL_StringRef &name, CL_Vec2i vec) {set_uniform2i(name, vec.x, vec.y);}

        void set_uniform3i(const CL_StringRef &name, CL_Vec3i vec) {set_uniform3i(name, vec.x, vec.y, vec.z);}

        void set_uniform4i(const CL_StringRef &name, CL_Vec4i vec) {set_uniform4i(name, vec.x, vec.y, vec.z, vec.w);}

        void set_uniform2s(const CL_StringRef &name, CL_Vec2s vec) {set_uniform2i(name, vec.x, vec.y);}

        void set_uniform3s(const CL_StringRef &name, CL_Vec3s vec) {set_uniform3i(name, vec.x, vec.y, vec.z);}

        void set_uniform4s(const CL_StringRef &name, CL_Vec4s vec) {set_uniform4i(name, vec.x, vec.y, vec.z, vec.w);}

        void set_uniform2b(const CL_StringRef &name, CL_Vec2b vec) {set_uniform2i(name, vec.x, vec.y);}

        void set_uniform3b(const CL_StringRef &name, CL_Vec3b vec) {set_uniform3i(name, vec.x, vec.y, vec.z);}

        void set_uniform4b(const CL_StringRef &name, CL_Vec4b vec) {set_uniform4i(name, vec.x, vec.y, vec.z, vec.w);}

        void set_uniformiv(const CL_StringRef &name, int count, CL_Vec2i *data) {set_uniformiv(name, 2, count, *data);}

        void set_uniformiv(const CL_StringRef &name, int count, CL_Vec3i *data) {set_uniformiv(name, 3, count, *data);}

        void set_uniformiv(const CL_StringRef &name, int count, CL_Vec4i *data) {set_uniformiv(name, 4, count, *data);}

        void set_uniform1f(const CL_StringRef &name, float value_a);

        void set_uniform2f(const CL_StringRef &name, float value_a, float value_b);

        void set_uniform3f(const CL_StringRef &name, float value_a, float value_b, float value_c);

        void set_uniform4f(const CL_StringRef &name, float value_a, float value_b, float value_c, float value_d);

        void set_uniformfv(const CL_StringRef &name, int size, int count, float *data);

        void set_uniform2f(const CL_StringRef &name, CL_Vec2f vec) {set_uniform2f(name, vec.x, vec.y);}

        void set_uniform3f(const CL_StringRef &name, CL_Vec3f vec) {set_uniform3f(name, vec.x, vec.y, vec.z);}

        void set_uniform4f(const CL_StringRef &name, CL_Vec4f vec) {set_uniform4f(name, vec.x, vec.y, vec.z, vec.w);}

        void set_uniformfv(const CL_StringRef &name, int count, CL_Vec2f *data) {set_uniformfv(name, 2, count, *data);}

        void set_uniformfv(const CL_StringRef &name, int count, CL_Vec3f *data) {set_uniformfv(name, 3, count, *data);}

        void set_uniformfv(const CL_StringRef &name, int count, CL_Vec4f *data) {set_uniformfv(name, 4, count, *data);}

        void set_uniform_matrix(const CL_StringRef &name, int size, int count, bool transpose, float *data);

        void set_uniform_matrix(const CL_StringRef &name, CL_Mat2f matrix) {set_uniform_matrix(name, 2, 1, false, matrix.matrix);}

        void set_uniform_matrix(const CL_StringRef &name, CL_Mat3f matrix) {set_uniform_matrix(name, 3, 1, false, matrix.matrix);}

        void set_uniform_matrix(const CL_StringRef &name, CL_Mat4f matrix) {set_uniform_matrix(name, 4, 1, false, matrix.matrix);}

        void set_uniform_matrix(const CL_StringRef &name, int count, CL_Mat2f *matrix) {set_uniform_matrix(name, 2, count, false, matrix->matrix);}

        void set_uniform_matrix(const CL_StringRef &name, int count, CL_Mat3f *matrix) {set_uniform_matrix(name, 3, count, false, matrix->matrix);}

        void set_uniform_matrix(const CL_StringRef &name, int count, CL_Mat4f *matrix) {set_uniform_matrix(name, 4, count, false, matrix->matrix);}


private:
        CL_SharedPtr<CL_ProgramObject_Impl> impl;
};