← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to intern/cycles/render/osl.h

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
intern/cycles/render/osl.h
20
20
#define __OSL_H__
21
21
 
22
22
#include "util_set.h"
 
23
#include "util_string.h"
23
24
 
24
25
#include "shader.h"
25
26
 
26
27
#ifdef WITH_OSL
 
28
#include <OSL/oslcomp.h>
27
29
#include <OSL/oslexec.h>
 
30
#include <OSL/oslquery.h>
28
31
#endif
29
32
 
30
33
CCL_NAMESPACE_BEGIN
33
36
class DeviceScene;
34
37
class ImageManager;
35
38
class OSLRenderServices;
36
 
class OSLGlobals;
 
39
struct OSLGlobals;
37
40
class Scene;
38
41
class ShaderGraph;
39
42
class ShaderNode;
 
43
class ShaderInput;
40
44
class ShaderOutput;
41
45
 
42
46
#ifdef WITH_OSL
43
47
 
 
48
/* OSL Shader Info
 
49
 * to auto detect closures in the shader for MIS and transparent shadows */
 
50
 
 
51
struct OSLShaderInfo {
 
52
        OSLShaderInfo()
 
53
        : has_surface_emission(false), has_surface_transparent(false)
 
54
        {}
 
55
 
 
56
        bool has_surface_emission;
 
57
        bool has_surface_transparent;
 
58
};
 
59
 
44
60
/* Shader Manage */
45
61
 
46
62
class OSLShaderManager : public ShaderManager {
48
64
        OSLShaderManager();
49
65
        ~OSLShaderManager();
50
66
 
 
67
        void reset(Scene *scene);
 
68
 
 
69
        bool use_osl() { return true; }
 
70
 
51
71
        void device_update(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress);
52
72
        void device_free(Device *device, DeviceScene *dscene);
53
73
 
54
 
private:
 
74
        /* osl compile and query */
 
75
        static bool osl_compile(const string& inputfile, const string& outputfile);
 
76
        static bool osl_query(OSL::OSLQuery& query, const string& filepath);
 
77
 
 
78
        /* shader file loading, all functions return pointer to hash string if found */
 
79
        const char *shader_test_loaded(const string& hash);
 
80
        const char *shader_load_bytecode(const string& hash, const string& bytecode);
 
81
        const char *shader_load_filepath(string filepath);
 
82
        OSLShaderInfo *shader_loaded_info(const string& hash);
 
83
 
 
84
protected:
 
85
        void texture_system_init();
 
86
        void shading_system_init();
 
87
 
55
88
        OSL::ShadingSystem *ss;
56
89
        OSL::TextureSystem *ts;
57
90
        OSLRenderServices *services;
58
91
        OSL::ErrorHandler errhandler;
 
92
        map<string, OSLShaderInfo> loaded_shaders;
59
93
};
60
94
 
61
95
#endif
64
98
 
65
99
class OSLCompiler {
66
100
public:
67
 
        OSLCompiler(void *shadingsys);
 
101
        OSLCompiler(void *manager, void *shadingsys, ImageManager *image_manager);
68
102
        void compile(OSLGlobals *og, Shader *shader);
69
103
 
70
 
        void add(ShaderNode *node, const char *name);
 
104
        void add(ShaderNode *node, const char *name, bool isfilepath = false);
71
105
 
72
106
        void parameter(const char *name, float f);
73
107
        void parameter_color(const char *name, float3 f);
79
113
        void parameter(const char *name, ustring str);
80
114
        void parameter(const char *name, const Transform& tfm);
81
115
 
 
116
        void parameter_array(const char *name, const float f[], int arraylen);
 
117
        void parameter_color_array(const char *name, const float f[][3], int arraylen);
 
118
        void parameter_vector_array(const char *name, const float f[][3], int arraylen);
 
119
        void parameter_normal_array(const char *name, const float f[][3], int arraylen);
 
120
        void parameter_point_array(const char *name, const float f[][3], int arraylen);
 
121
        void parameter_array(const char *name, const int f[], int arraylen);
 
122
        void parameter_array(const char *name, const char * const s[], int arraylen);
 
123
        void parameter_array(const char *name, const Transform tfm[], int arraylen);
 
124
 
82
125
        ShaderType output_type() { return current_type; }
83
126
 
84
127
        bool background;
 
128
        ImageManager *image_manager;
85
129
 
86
130
private:
87
131
        string id(ShaderNode *node);
88
132
        void compile_type(Shader *shader, ShaderGraph *graph, ShaderType type);
89
133
        bool node_skip_input(ShaderNode *node, ShaderInput *input);
90
 
        string compatible_name(const char *name);
 
134
        string compatible_name(ShaderNode *node, ShaderInput *input);
 
135
        string compatible_name(ShaderNode *node, ShaderOutput *output);
91
136
 
92
137
        void find_dependencies(set<ShaderNode*>& dependencies, ShaderInput *input);
93
138
        void generate_nodes(const set<ShaderNode*>& nodes);
94
139
 
95
140
        void *shadingsys;
 
141
        void *manager;
96
142
        ShaderType current_type;
97
143
        Shader *current_shader;
98
144
};