VirtualBox

source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_getshaders.c@ 71532

Last change on this file since 71532 was 69500, checked in by vboxsync, 7 years ago

*: scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 11.4 KB
Line 
1/* $Id: server_getshaders.c 69500 2017-10-28 15:14:05Z vboxsync $ */
2/** @file
3 * VBox OpenGL GLSL related get functions
4 */
5
6/*
7 * Copyright (C) 2009-2017 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#include "cr_spu.h"
19#include "chromium.h"
20#include "cr_error.h"
21#include "cr_mem.h"
22#include "cr_net.h"
23#include "server_dispatch.h"
24#include "server.h"
25
26#include <iprt/assert.h>
27
28#ifdef CR_OPENGL_VERSION_2_0
29
30typedef struct _crGetActive_t
31{
32 GLsizei length;
33 GLint size;
34 GLenum type;
35} crGetActive_t;
36
37void SERVER_DISPATCH_APIENTRY crServerDispatchGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, char *name)
38{
39 crGetActive_t *pLocal;
40
41 pLocal = (crGetActive_t*) crAlloc(bufSize+sizeof(crGetActive_t));
42 if (!pLocal)
43 {
44 crGetActive_t zero;
45 zero.length = 0;
46 crServerReturnValue(&zero, sizeof(zero));
47 return;
48 }
49 /* zero out just the header to ensure it initially contains zero size values */
50 memset(pLocal, 0, sizeof (*pLocal));
51 cr_server.head_spu->dispatch_table.GetActiveAttrib(crStateGetProgramHWID(program), index, bufSize, &pLocal->length, &pLocal->size, &pLocal->type, (char*)&pLocal[1]);
52 crServerReturnValue(pLocal, pLocal->length+1+sizeof(crGetActive_t));
53 crFree(pLocal);
54}
55
56void SERVER_DISPATCH_APIENTRY crServerDispatchGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, char *name)
57{
58 crGetActive_t *pLocal;
59
60 pLocal = (crGetActive_t*) crAlloc(bufSize+sizeof(crGetActive_t));
61 if (!pLocal)
62 {
63 crGetActive_t zero;
64 zero.length = 0;
65 crServerReturnValue(&zero, sizeof(zero));
66 return;
67 }
68 /* zero out just the header to ensure it initially contains zero size values */
69 memset(pLocal, 0, sizeof (*pLocal));
70 cr_server.head_spu->dispatch_table.GetActiveUniform(crStateGetProgramHWID(program), index, bufSize, &pLocal->length, &pLocal->size, &pLocal->type, (char*)&pLocal[1]);
71 crServerReturnValue(pLocal, pLocal->length+1+sizeof(crGetActive_t));
72 crFree(pLocal);
73}
74
75void SERVER_DISPATCH_APIENTRY crServerDispatchGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
76{
77 GLsizei *pLocal;
78
79 pLocal = (GLsizei*) crAlloc(maxCount*sizeof(GLuint)+sizeof(GLsizei));
80 if (!pLocal)
81 {
82 GLsizei zero=0;
83 crServerReturnValue(&zero, sizeof(zero));
84 return;
85 }
86 /* initial (fallback )value */
87 *pLocal = 0;
88 cr_server.head_spu->dispatch_table.GetAttachedShaders(crStateGetProgramHWID(program), maxCount, pLocal, (GLuint*)&pLocal[1]);
89
90 {
91 GLsizei i;
92 GLuint *ids=(GLuint*)&pLocal[1];
93
94 for (i=0; i<*pLocal; ++i)
95 ids[i] = crStateGLSLShaderHWIDtoID(ids[i]);
96 }
97
98 crServerReturnValue(pLocal, (*pLocal)*sizeof(GLuint)+sizeof(GLsizei));
99 crFree(pLocal);
100}
101
102void SERVER_DISPATCH_APIENTRY crServerDispatchGetAttachedObjectsARB(VBoxGLhandleARB containerObj, GLsizei maxCount, GLsizei * count, VBoxGLhandleARB * obj)
103{
104 GLsizei *pLocal;
105
106 pLocal = (GLsizei*) crAlloc(maxCount*sizeof(VBoxGLhandleARB)+sizeof(GLsizei));
107 if (!pLocal)
108 {
109 GLsizei zero=0;
110 crServerReturnValue(&zero, sizeof(zero));
111 return;
112 }
113 /* initial (fallback )value */
114 *pLocal = 0;
115 cr_server.head_spu->dispatch_table.GetAttachedObjectsARB(crStateGetProgramHWID(containerObj), maxCount, pLocal, (VBoxGLhandleARB*)&pLocal[1]);
116
117 {
118 GLsizei i;
119 GLuint *ids=(GLuint*)&pLocal[1];
120
121 for (i=0; i<*pLocal; ++i)
122 ids[i] = crStateGLSLShaderHWIDtoID(ids[i]);
123 }
124
125 crServerReturnValue(pLocal, (*pLocal)*sizeof(VBoxGLhandleARB)+sizeof(GLsizei));
126 crFree(pLocal);
127}
128
129AssertCompile(sizeof(GLsizei) == 4);
130
131void SERVER_DISPATCH_APIENTRY crServerDispatchGetInfoLogARB(VBoxGLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog)
132{
133 GLsizei *pLocal;
134 GLuint hwid;
135
136 pLocal = (GLsizei*) crAlloc(maxLength+sizeof(GLsizei));
137 if (!pLocal)
138 {
139 GLsizei zero=0;
140 crServerReturnValue(&zero, sizeof(zero));
141 return;
142 }
143 /* initial (fallback )value */
144 *pLocal = 0;
145 /** @todo recheck*/
146 hwid = crStateGetProgramHWID(obj);
147 if (!hwid) hwid = crStateGetShaderHWID(obj);
148 cr_server.head_spu->dispatch_table.GetInfoLogARB(hwid, maxLength, pLocal, (char*)&pLocal[1]);
149 CRASSERT((*pLocal) <= maxLength);
150 crServerReturnValue(pLocal, (*pLocal)+sizeof(GLsizei));
151 crFree(pLocal);
152}
153
154void SERVER_DISPATCH_APIENTRY crServerDispatchGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, char *infoLog)
155{
156 GLsizei *pLocal;
157
158 pLocal = (GLsizei*) crAlloc(bufSize+sizeof(GLsizei));
159 if (!pLocal)
160 {
161 GLsizei zero=0;
162 crServerReturnValue(&zero, sizeof(zero));
163 return;
164 }
165 /* initial (fallback )value */
166 *pLocal = 0;
167 cr_server.head_spu->dispatch_table.GetShaderInfoLog(crStateGetShaderHWID(shader), bufSize, pLocal, (char*)&pLocal[1]);
168 crServerReturnValue(pLocal, pLocal[0]+sizeof(GLsizei));
169 crFree(pLocal);
170}
171
172void SERVER_DISPATCH_APIENTRY crServerDispatchGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, char *infoLog)
173{
174 GLsizei *pLocal;
175
176 pLocal = (GLsizei*) crAlloc(bufSize+sizeof(GLsizei));
177 if (!pLocal)
178 {
179 GLsizei zero=0;
180 crServerReturnValue(&zero, sizeof(zero));
181 return;
182 }
183 /* initial (fallback )value */
184 *pLocal = 0;
185 cr_server.head_spu->dispatch_table.GetProgramInfoLog(crStateGetProgramHWID(program), bufSize, pLocal, (char*)&pLocal[1]);
186 CRASSERT(pLocal[0] <= bufSize);
187 crServerReturnValue(pLocal, pLocal[0]+sizeof(GLsizei));
188 crFree(pLocal);
189}
190
191void SERVER_DISPATCH_APIENTRY crServerDispatchGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, char *source)
192{
193 GLsizei *pLocal;
194
195 pLocal = (GLsizei*) crAlloc(bufSize+sizeof(GLsizei));
196 if (!pLocal)
197 {
198 GLsizei zero=0;
199 crServerReturnValue(&zero, sizeof(zero));
200 return;
201 }
202 /* initial (fallback )value */
203 *pLocal = 0;
204 cr_server.head_spu->dispatch_table.GetShaderSource(crStateGetShaderHWID(shader), bufSize, pLocal, (char*)&pLocal[1]);
205 CRASSERT(pLocal[0] <= bufSize);
206 crServerReturnValue(pLocal, pLocal[0]+sizeof(GLsizei));
207 crFree(pLocal);
208}
209
210void SERVER_DISPATCH_APIENTRY
211crServerDispatchGetUniformsLocations(GLuint program, GLsizei maxcbData, GLsizei * cbData, GLvoid * pData)
212{
213 GLsizei *pLocal;
214
215 (void) cbData;
216 (void) pData;
217
218 pLocal = (GLsizei*) crAlloc(maxcbData+sizeof(GLsizei));
219 if (!pLocal)
220 {
221 GLsizei zero=0;
222 crServerReturnValue(&zero, sizeof(zero));
223 return;
224 }
225
226 /* initial (fallback )value */
227 *pLocal = 0;
228 crStateGLSLProgramCacheUniforms(program, maxcbData, pLocal, (char*)&pLocal[1]);
229
230 crServerReturnValue(pLocal, (*pLocal)+sizeof(GLsizei));
231 crFree(pLocal);
232}
233
234void SERVER_DISPATCH_APIENTRY
235crServerDispatchGetAttribsLocations(GLuint program, GLsizei maxcbData, GLsizei * cbData, GLvoid * pData)
236{
237 GLsizei *pLocal;
238
239 (void) cbData;
240 (void) pData;
241
242 pLocal = (GLsizei*) crAlloc(maxcbData+sizeof(GLsizei));
243 if (!pLocal)
244 {
245 GLsizei zero=0;
246 crServerReturnValue(&zero, sizeof(zero));
247 return;
248 }
249
250 /* initial (fallback )value */
251 *pLocal = 0;
252 crStateGLSLProgramCacheAttribs(program, maxcbData, pLocal, (char*)&pLocal[1]);
253
254 crServerReturnValue(pLocal, (*pLocal)+sizeof(GLsizei));
255 crFree(pLocal);
256}
257
258static GLint __GetUniformSize(GLuint program, GLint location)
259{
260 GLint size = 0;
261 GLenum type = 0;
262
263 /** @todo check if index and location is the same*/
264 cr_server.head_spu->dispatch_table.GetActiveUniform(crStateGetProgramHWID(program), location, 0, NULL, &size, &type, NULL);
265
266 return crStateGetUniformSize(type);
267}
268
269void SERVER_DISPATCH_APIENTRY crServerDispatchGetUniformfv(GLuint program, GLint location, GLfloat *params)
270{
271 int size = __GetUniformSize(program, location) * sizeof(GLfloat);
272 GLfloat *pLocal;
273
274 pLocal = (GLfloat*) crAlloc(size);
275 if (!pLocal)
276 {
277 GLsizei zero=0;
278 crServerReturnValue(&zero, sizeof(zero));
279 return;
280 }
281
282 cr_server.head_spu->dispatch_table.GetUniformfv(crStateGetProgramHWID(program), location, pLocal);
283
284 crServerReturnValue(pLocal, size);
285 crFree(pLocal);
286}
287
288void SERVER_DISPATCH_APIENTRY crServerDispatchGetUniformiv(GLuint program, GLint location, GLint *params)
289{
290 int size = __GetUniformSize(program, location) * sizeof(GLint);
291 GLint *pLocal;
292
293 pLocal = (GLint*) crAlloc(size);
294 if (!pLocal)
295 {
296 GLsizei zero=0;
297 crServerReturnValue(&zero, sizeof(zero));
298 return;
299 }
300
301 cr_server.head_spu->dispatch_table.GetUniformiv(crStateGetProgramHWID(program), location, pLocal);
302
303 crServerReturnValue(pLocal, size);
304 crFree(pLocal);
305}
306
307GLuint SERVER_DISPATCH_APIENTRY crServerDispatchCreateShader(GLenum type)
308{
309 GLuint retval, hwVal;
310 hwVal = cr_server.head_spu->dispatch_table.CreateShader(type);
311 retval = crStateCreateShader(hwVal, type);
312 crServerReturnValue(&retval, sizeof(retval));
313 return retval; /* ignored */
314}
315
316GLuint SERVER_DISPATCH_APIENTRY crServerDispatchCreateProgram(void)
317{
318 GLuint retval, hwVal;
319 hwVal = cr_server.head_spu->dispatch_table.CreateProgram();
320 retval = crStateCreateProgram(hwVal);
321 crServerReturnValue(&retval, sizeof(retval));
322 return retval; /* ignored */
323}
324
325GLboolean SERVER_DISPATCH_APIENTRY crServerDispatchIsShader(GLuint shader)
326{
327 GLboolean retval;
328 retval = cr_server.head_spu->dispatch_table.IsShader(crStateGetShaderHWID(shader));
329 crServerReturnValue(&retval, sizeof(retval));
330 return retval; /* ignored */
331}
332
333GLboolean SERVER_DISPATCH_APIENTRY crServerDispatchIsProgram(GLuint program)
334{
335 GLboolean retval;
336 retval = cr_server.head_spu->dispatch_table.IsProgram(crStateGetProgramHWID(program));
337 crServerReturnValue(&retval, sizeof(retval));
338 return retval; /* ignored */
339}
340
341void SERVER_DISPATCH_APIENTRY crServerDispatchGetObjectParameterfvARB( VBoxGLhandleARB obj, GLenum pname, GLfloat * params )
342{
343 GLfloat local_params[1];
344 GLuint hwid = crStateGetProgramHWID(obj);
345 (void) params;
346
347 if (!hwid)
348 {
349 hwid = crStateGetShaderHWID(obj);
350 if (!hwid)
351 {
352 crWarning("Unknown object %i, in crServerDispatchGetObjectParameterfvARB", obj);
353 }
354 }
355
356 cr_server.head_spu->dispatch_table.GetObjectParameterfvARB( hwid, pname, local_params );
357 crServerReturnValue( &(local_params[0]), 1*sizeof(GLfloat) );
358}
359
360void SERVER_DISPATCH_APIENTRY crServerDispatchGetObjectParameterivARB( VBoxGLhandleARB obj, GLenum pname, GLint * params )
361{
362 GLint local_params[1];
363 GLuint hwid = crStateGetProgramHWID(obj);
364 if (!hwid)
365 {
366 hwid = crStateGetShaderHWID(obj);
367 if (!hwid)
368 {
369 crWarning("Unknown object %i, in crServerDispatchGetObjectParameterivARB", obj);
370 }
371 }
372
373 (void) params;
374 cr_server.head_spu->dispatch_table.GetObjectParameterivARB( hwid, pname, local_params );
375 crServerReturnValue( &(local_params[0]), 1*sizeof(GLint) );
376}
377#endif /* #ifdef CR_OPENGL_VERSION_2_0 */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette