gallium/target: Haiku softpipe
[mesa.git] / src / hgl / GLRendererRoster.cpp
1 /*
2 * Copyright 2006-2012 Haiku, Inc. All Rights Reserved.
3 * Distributed under the terms of the MIT License.
4 *
5 * Authors:
6 * Philippe Houdoin <philippe.houdoin@free.fr>
7 * Alexander von Gluck IV <kallisti5@unixzen.com>
8 */
9
10
11 #include <driver_settings.h>
12 #include <image.h>
13
14 #include <kernel/image.h>
15 #include <system/safemode_defs.h>
16
17 #include <Directory.h>
18 #include <FindDirectory.h>
19 #include <Path.h>
20 #include <strings.h>
21 #include "GLDispatcher.h"
22 #include "GLRendererRoster.h"
23
24 #include <new>
25 #include <string.h>
26
27
28 extern "C" status_t _kern_get_safemode_option(const char* parameter,
29 char* buffer, size_t* _bufferSize);
30
31
32 GLRendererRoster::GLRendererRoster(BGLView* view, ulong options)
33 :
34 fNextID(0),
35 fView(view),
36 fOptions(options),
37 fSafeMode(false),
38 fABISubDirectory(NULL)
39 {
40 char parameter[32];
41 size_t parameterLength = sizeof(parameter);
42
43 if (_kern_get_safemode_option(B_SAFEMODE_SAFE_MODE,
44 parameter, &parameterLength) == B_OK) {
45 if (!strcasecmp(parameter, "enabled") || !strcasecmp(parameter, "on")
46 || !strcasecmp(parameter, "true") || !strcasecmp(parameter, "yes")
47 || !strcasecmp(parameter, "enable") || !strcmp(parameter, "1"))
48 fSafeMode = true;
49 }
50
51 if (_kern_get_safemode_option(B_SAFEMODE_DISABLE_USER_ADD_ONS,
52 parameter, &parameterLength) == B_OK) {
53 if (!strcasecmp(parameter, "enabled") || !strcasecmp(parameter, "on")
54 || !strcasecmp(parameter, "true") || !strcasecmp(parameter, "yes")
55 || !strcasecmp(parameter, "enable") || !strcmp(parameter, "1"))
56 fSafeMode = true;
57 }
58
59 // We might run in compatibility mode on a system with a different ABI. The
60 // renderers matching our ABI can usually be found in respective
61 // subdirectories of the opengl add-ons directories.
62 system_info info;
63 if (get_system_info(&info) == B_OK
64 && (info.abi & B_HAIKU_ABI_MAJOR)
65 != (B_HAIKU_ABI & B_HAIKU_ABI_MAJOR)) {
66 switch (B_HAIKU_ABI & B_HAIKU_ABI_MAJOR) {
67 case B_HAIKU_ABI_GCC_2:
68 fABISubDirectory = "gcc2";
69 break;
70 case B_HAIKU_ABI_GCC_4:
71 fABISubDirectory = "gcc4";
72 break;
73 }
74 }
75
76 AddDefaultPaths();
77 }
78
79
80 GLRendererRoster::~GLRendererRoster()
81 {
82
83 }
84
85
86 BGLRenderer*
87 GLRendererRoster::GetRenderer(int32 id)
88 {
89 RendererMap::const_iterator iterator = fRenderers.find(id);
90 if (iterator == fRenderers.end())
91 return NULL;
92
93 struct renderer_item item = iterator->second;
94 return item.renderer;
95 }
96
97
98 void
99 GLRendererRoster::AddDefaultPaths()
100 {
101 // add user directories first, so that they can override system renderers
102 const directory_which paths[] = {
103 B_USER_NONPACKAGED_ADDONS_DIRECTORY,
104 B_USER_ADDONS_DIRECTORY,
105 B_SYSTEM_ADDONS_DIRECTORY,
106 };
107
108 for (uint32 i = fSafeMode ? 4 : 0;
109 i < sizeof(paths) / sizeof(paths[0]); i++) {
110 BPath path;
111 status_t status = find_directory(paths[i], &path, true);
112 if (status == B_OK && path.Append("opengl") == B_OK)
113 AddPath(path.Path());
114 }
115 }
116
117
118 status_t
119 GLRendererRoster::AddPath(const char* path)
120 {
121 BDirectory directory(path);
122 status_t status = directory.InitCheck();
123 if (status < B_OK)
124 return status;
125
126 // if a subdirectory for our ABI exists, use that instead
127 if (fABISubDirectory != NULL) {
128 BEntry entry(&directory, fABISubDirectory);
129 if (entry.IsDirectory()) {
130 status = directory.SetTo(&entry);
131 if (status != B_OK)
132 return status;
133 }
134 }
135
136 node_ref nodeRef;
137 status = directory.GetNodeRef(&nodeRef);
138 if (status < B_OK)
139 return status;
140
141 int32 count = 0;
142 int32 files = 0;
143
144 entry_ref ref;
145 BEntry entry;
146 while (directory.GetNextRef(&ref) == B_OK) {
147 entry.SetTo(&ref);
148 if (entry.InitCheck() == B_OK && !entry.IsFile())
149 continue;
150
151 if (CreateRenderer(ref) == B_OK)
152 count++;
153
154 files++;
155 }
156
157 if (files != 0 && count == 0)
158 return B_BAD_VALUE;
159
160 return B_OK;
161 }
162
163
164 status_t
165 GLRendererRoster::AddRenderer(BGLRenderer* renderer,
166 image_id image, const entry_ref* ref, ino_t node)
167 {
168 renderer_item item;
169 item.renderer = renderer;
170 item.image = image;
171 item.node = node;
172 if (ref != NULL)
173 item.ref = *ref;
174
175 try {
176 fRenderers[fNextID] = item;
177 } catch (...) {
178 return B_NO_MEMORY;
179 }
180
181 renderer->fOwningRoster = this;
182 renderer->fID = fNextID++;
183 return B_OK;
184 }
185
186
187 status_t
188 GLRendererRoster::CreateRenderer(const entry_ref& ref)
189 {
190 BEntry entry(&ref);
191 node_ref nodeRef;
192 status_t status = entry.GetNodeRef(&nodeRef);
193 if (status < B_OK)
194 return status;
195
196 BPath path(&ref);
197 image_id image = load_add_on(path.Path());
198 if (image < B_OK)
199 return image;
200
201 BGLRenderer* (*instantiate_renderer)
202 (BGLView* view, ulong options, BGLDispatcher* dispatcher);
203
204 status = get_image_symbol(image, "instantiate_gl_renderer",
205 B_SYMBOL_TYPE_TEXT, (void**)&instantiate_renderer);
206 if (status == B_OK) {
207 BGLRenderer* renderer
208 = instantiate_renderer(fView, fOptions, new BGLDispatcher());
209 if (!renderer) {
210 unload_add_on(image);
211 return B_UNSUPPORTED;
212 }
213
214 if (AddRenderer(renderer, image, &ref, nodeRef.node) != B_OK) {
215 renderer->Release();
216 // this will delete the renderer
217 unload_add_on(image);
218 }
219 return B_OK;
220 }
221 unload_add_on(image);
222
223 return status;
224 }