VirtualBox

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

Last change on this file since 33223 was 33045, checked in by vboxsync, 14 years ago

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