Cleanup: unused vars, imports, pep8
[blender.git] / intern / cycles / blender / addon / engine.py
1 #
2 # Copyright 2011-2013 Blender Foundation
3 #
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at
7 #
8 # http://www.apache.org/licenses/LICENSE-2.0
9 #
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
15 #
16
17 # <pep8 compliant>
18
19
20 def _is_using_buggy_driver():
21     import bgl
22     # We need to be conservative here because in multi-GPU systems display card
23     # might be quite old, but others one might be just good.
24     #
25     # So We shouldn't disable possible good dedicated cards just because display
26     # card seems weak. And instead we only blacklist configurations which are
27     # proven to cause problems.
28     if bgl.glGetString(bgl.GL_VENDOR) == "ATI Technologies Inc.":
29         import re
30         version = bgl.glGetString(bgl.GL_VERSION)
31         if version.endswith("Compatibility Profile Context"):
32             # Old HD 4xxx and 5xxx series drivers did not have driver version
33             # in the version string, but those cards do not quite work and
34             # causing crashes.
35             return True
36         regex = re.compile(".*Compatibility Profile Context ([0-9]+(\.[0-9]+)+)$")
37         if not regex.match(version):
38             # Skip cards like FireGL
39             return False
40         version = regex.sub("\\1", version).split('.')
41         return int(version[0]) == 8
42     return False
43
44
45 def _workaround_buggy_drivers():
46     if _is_using_buggy_driver():
47         import _cycles
48         if hasattr(_cycles, "opencl_disable"):
49             print("Cycles: OpenGL driver known to be buggy, disabling OpenCL platform.")
50             _cycles.opencl_disable()
51
52
53 def _parse_command_line():
54     import sys
55
56     argv = sys.argv
57     if "--" not in argv:
58         return
59
60     argv = argv[argv.index("--") + 1:]
61
62     num_resumable_chunks = None
63     current_resumable_chunk = None
64
65     # TODO(sergey): Add some nice error ptins if argument is not used properly.
66     idx = 0
67     while idx < len(argv) - 1:
68         arg = argv[idx]
69         if arg == '--cycles-resumable-num-chunks':
70             num_resumable_chunks = int(argv[idx + 1])
71         elif arg == '--cycles-resumable-current-chunk':
72             current_resumable_chunk = int(argv[idx + 1])
73         idx += 1
74
75     if num_resumable_chunks is not None and current_resumable_chunk is not None:
76         import _cycles
77         _cycles.set_resumable_chunks(num_resumable_chunks,
78                                      current_resumable_chunk)
79
80
81 def init():
82     import bpy
83     import _cycles
84     import os.path
85
86     # Workaround possibly buggy legacy drivers which crashes on the OpenCL
87     # device enumeration.
88     #
89     # This checks are not really correct because they might still fail
90     # in the case of multiple GPUs. However, currently buggy drivers
91     # are really old and likely to be used in single GPU systems only
92     # anyway.
93     #
94     # Can't do it in the background mode, so we hope OpenCL is no enabled
95     # in the user preferences.
96     if not bpy.app.background:
97         _workaround_buggy_drivers()
98
99     path = os.path.dirname(__file__)
100     user_path = os.path.dirname(os.path.abspath(bpy.utils.user_resource('CONFIG', '')))
101
102     _cycles.init(path, user_path, bpy.app.background)
103     _parse_command_line()
104
105
106 def exit():
107     import _cycles
108     _cycles.exit()
109
110
111 def create(engine, data, scene, region=None, v3d=None, rv3d=None, preview_osl=False):
112     import bpy
113     import _cycles
114
115     data = data.as_pointer()
116     userpref = bpy.context.user_preferences.as_pointer()
117     scene = scene.as_pointer()
118     if region:
119         region = region.as_pointer()
120     if v3d:
121         v3d = v3d.as_pointer()
122     if rv3d:
123         rv3d = rv3d.as_pointer()
124
125     if bpy.app.debug_value == 256:
126         _cycles.debug_flags_update(scene)
127     else:
128         _cycles.debug_flags_reset()
129
130     engine.session = _cycles.create(engine.as_pointer(), userpref, data, scene, region, v3d, rv3d, preview_osl)
131
132
133 def free(engine):
134     if hasattr(engine, "session"):
135         if engine.session:
136             import _cycles
137             _cycles.free(engine.session)
138         del engine.session
139
140
141 def render(engine):
142     import _cycles
143     if hasattr(engine, "session"):
144         _cycles.render(engine.session)
145
146
147 def bake(engine, obj, pass_type, pass_filter, object_id, pixel_array, num_pixels, depth, result):
148     import _cycles
149     session = getattr(engine, "session", None)
150     if session is not None:
151         _cycles.bake(engine.session, obj.as_pointer(), pass_type, pass_filter, object_id, pixel_array.as_pointer(), num_pixels, depth, result.as_pointer())
152
153
154 def reset(engine, data, scene):
155     import _cycles
156     data = data.as_pointer()
157     scene = scene.as_pointer()
158     _cycles.reset(engine.session, data, scene)
159
160
161 def update(engine, data, scene):
162     import _cycles
163     _cycles.sync(engine.session)
164
165
166 def draw(engine, region, v3d, rv3d):
167     import _cycles
168     v3d = v3d.as_pointer()
169     rv3d = rv3d.as_pointer()
170
171     # draw render image
172     _cycles.draw(engine.session, v3d, rv3d)
173
174
175 def available_devices():
176     import _cycles
177     return _cycles.available_devices()
178
179
180 def with_osl():
181     import _cycles
182     return _cycles.with_osl
183
184
185 def with_network():
186     import _cycles
187     return _cycles.with_network
188
189
190 def system_info():
191     import _cycles
192     return _cycles.system_info()