/src/mozilla-central/dom/canvas/WebGLUniformLocation.cpp

Source (jump to first uncovered line)
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "WebGLUniformLocation.h"

#include "GLContext.h"
#include "mozilla/dom/ToJSValue.h"
#include "mozilla/dom/WebGLRenderingContextBinding.h"
#include "WebGLActiveInfo.h"
#include "WebGLContext.h"
#include "WebGLProgram.h"

namespace mozilla {

WebGLUniformLocation::WebGLUniformLocation(WebGLContext* webgl,
                                           const webgl::LinkedProgramInfo* linkInfo,
                                           webgl::UniformInfo* info, GLuint loc,
                                           size_t arrayIndex)
    : WebGLContextBoundObject(webgl)
    , mLinkInfo(linkInfo)
    , mInfo(info)
    , mLoc(loc)
    , mArrayIndex(arrayIndex)
{ }

WebGLUniformLocation::~WebGLUniformLocation()
{ }

bool
WebGLUniformLocation::ValidateForProgram(const WebGLProgram* prog) const
{
    // Check the weak-pointer.
    if (!mLinkInfo) {
        mContext->ErrorInvalidOperation("This uniform location is obsolete because"
                                        " its program has been successfully relinked.");
        return false;
    }

    if (mLinkInfo->prog != prog) {
        mContext->ErrorInvalidOperation("This uniform location corresponds to a"
                                        " different program.");
        return false;
    }

    return true;
}

static bool
IsUniformSetterTypeValid(GLenum setterType, GLenum uniformType)
{
    // The order in this switch matches table 2.10 from OpenGL ES
    // 3.0.4 (Aug 27, 2014) es_spec_3.0.4.pdf
    switch (uniformType) {
    case LOCAL_GL_FLOAT:
    case LOCAL_GL_FLOAT_VEC2:
    case LOCAL_GL_FLOAT_VEC3:
    case LOCAL_GL_FLOAT_VEC4:
        return setterType == LOCAL_GL_FLOAT;

    case LOCAL_GL_INT:
    case LOCAL_GL_INT_VEC2:
    case LOCAL_GL_INT_VEC3:
    case LOCAL_GL_INT_VEC4:
        return setterType == LOCAL_GL_INT;

    case LOCAL_GL_UNSIGNED_INT:
    case LOCAL_GL_UNSIGNED_INT_VEC2:
    case LOCAL_GL_UNSIGNED_INT_VEC3:
    case LOCAL_GL_UNSIGNED_INT_VEC4:
        return setterType == LOCAL_GL_UNSIGNED_INT;

        /* bool can be set via any function: 0, 0.0f -> FALSE, _ -> TRUE */
    case LOCAL_GL_BOOL:
    case LOCAL_GL_BOOL_VEC2:
    case LOCAL_GL_BOOL_VEC3:
    case LOCAL_GL_BOOL_VEC4:
        return (setterType == LOCAL_GL_INT   ||
                setterType == LOCAL_GL_FLOAT ||
                setterType == LOCAL_GL_UNSIGNED_INT);

    case LOCAL_GL_FLOAT_MAT2:
    case LOCAL_GL_FLOAT_MAT3:
    case LOCAL_GL_FLOAT_MAT4:
    case LOCAL_GL_FLOAT_MAT2x3:
    case LOCAL_GL_FLOAT_MAT2x4:
    case LOCAL_GL_FLOAT_MAT3x2:
    case LOCAL_GL_FLOAT_MAT3x4:
    case LOCAL_GL_FLOAT_MAT4x2:
    case LOCAL_GL_FLOAT_MAT4x3:
        return setterType == LOCAL_GL_FLOAT;

        /* Samplers can only be set via Uniform1i */
    case LOCAL_GL_SAMPLER_2D:
    case LOCAL_GL_SAMPLER_3D:
    case LOCAL_GL_SAMPLER_CUBE:
    case LOCAL_GL_SAMPLER_2D_SHADOW:
    case LOCAL_GL_SAMPLER_2D_ARRAY:
    case LOCAL_GL_SAMPLER_2D_ARRAY_SHADOW:
    case LOCAL_GL_SAMPLER_CUBE_SHADOW:

    case LOCAL_GL_INT_SAMPLER_2D:
    case LOCAL_GL_INT_SAMPLER_3D:
    case LOCAL_GL_INT_SAMPLER_CUBE:
    case LOCAL_GL_INT_SAMPLER_2D_ARRAY:

    case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D:
    case LOCAL_GL_UNSIGNED_INT_SAMPLER_3D:
    case LOCAL_GL_UNSIGNED_INT_SAMPLER_CUBE:
    case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
        return setterType == LOCAL_GL_INT;

    default:
        MOZ_CRASH("GFX: Bad `uniformType`.");
    }
}

bool
WebGLUniformLocation::ValidateSizeAndType(uint8_t setterElemSize, GLenum setterType) const
{
    MOZ_ASSERT(mLinkInfo);

    const auto& uniformElemSize = mInfo->mActiveInfo->mElemSize;
    if (setterElemSize != uniformElemSize) {
        mContext->ErrorInvalidOperation("Function used differs from uniform size: %i",
                                        uniformElemSize);
        return false;
    }

    const auto& uniformElemType = mInfo->mActiveInfo->mElemType;
    if (!IsUniformSetterTypeValid(setterType, uniformElemType)) {
        mContext->ErrorInvalidOperation("Function used is incompatible with uniform"
                                        " type: %i",
                                        uniformElemType);
        return false;
    }

    return true;
}

bool
WebGLUniformLocation::ValidateArrayLength(uint8_t setterElemSize,
                                          size_t setterArraySize) const
{
    MOZ_ASSERT(mLinkInfo);

    if (setterArraySize == 0 ||
        setterArraySize % setterElemSize)
    {
        mContext->ErrorInvalidValue("Expected an array of length a multiple of %d,"
                                    " got an array of length %zu.",
                                    setterElemSize, setterArraySize);
        return false;
    }

    /* GLES 2.0.25, Section 2.10, p38
     *   When loading `N` elements starting at an arbitrary position `k` in a uniform
     *   declared as an array, elements `k` through `k + N - 1` in the array will be
     *   replaced with the new values. Values for any array element that exceeds the
     *   highest array element index used, as reported by `GetActiveUniform`, will be
     *   ignored by GL.
     */
    if (!mInfo->mActiveInfo->mIsArray &&
        setterArraySize != setterElemSize)
    {
        mContext->ErrorInvalidOperation("Expected an array of length exactly %d"
                                        " (since this uniform is not an array uniform),"
                                        " got an array of length %zu.",
                                       setterElemSize, setterArraySize);
        return false;
    }

    return true;
}

JS::Value
WebGLUniformLocation::GetUniform(JSContext* js) const
{
    MOZ_ASSERT(mLinkInfo);

    const uint8_t elemSize = mInfo->mActiveInfo->mElemSize;
    static const uint8_t kMaxElemSize = 16;
    MOZ_ASSERT(elemSize <= kMaxElemSize);

    GLuint prog = mLinkInfo->prog->mGLName;

    gl::GLContext* gl = mContext->GL();

    switch (mInfo->mActiveInfo->mElemType) {
    case LOCAL_GL_INT:
    case LOCAL_GL_INT_VEC2:
    case LOCAL_GL_INT_VEC3:
    case LOCAL_GL_INT_VEC4:
    case LOCAL_GL_SAMPLER_2D:
    case LOCAL_GL_SAMPLER_3D:
    case LOCAL_GL_SAMPLER_CUBE:
    case LOCAL_GL_SAMPLER_2D_SHADOW:
    case LOCAL_GL_SAMPLER_2D_ARRAY:
    case LOCAL_GL_SAMPLER_2D_ARRAY_SHADOW:
    case LOCAL_GL_SAMPLER_CUBE_SHADOW:
    case LOCAL_GL_INT_SAMPLER_2D:
    case LOCAL_GL_INT_SAMPLER_3D:
    case LOCAL_GL_INT_SAMPLER_CUBE:
    case LOCAL_GL_INT_SAMPLER_2D_ARRAY:
    case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D:
    case LOCAL_GL_UNSIGNED_INT_SAMPLER_3D:
    case LOCAL_GL_UNSIGNED_INT_SAMPLER_CUBE:
    case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
        {
            GLint buffer[kMaxElemSize] = {0};
            gl->fGetUniformiv(prog, mLoc, buffer);

            if (elemSize == 1)
                return JS::Int32Value(buffer[0]);

            JSObject* obj = dom::Int32Array::Create(js, mContext, elemSize, buffer);
            if (!obj) {
                mContext->ErrorOutOfMemory("getUniform: Out of memory.");
                return JS::NullValue();
            }
            return JS::ObjectOrNullValue(obj);
        }

    case LOCAL_GL_BOOL:
    case LOCAL_GL_BOOL_VEC2:
    case LOCAL_GL_BOOL_VEC3:
    case LOCAL_GL_BOOL_VEC4:
        {
            GLint buffer[kMaxElemSize] = {0};
            gl->fGetUniformiv(prog, mLoc, buffer);

            if (elemSize == 1)
                return JS::BooleanValue(buffer[0]);

            bool boolBuffer[kMaxElemSize];
            for (uint8_t i = 0; i < kMaxElemSize; i++)
                boolBuffer[i] = buffer[i];

            JS::RootedValue val(js);
            // Be careful: we don't want to convert all of |uv|!
            if (!dom::ToJSValue(js, boolBuffer, elemSize, &val)) {
                mContext->ErrorOutOfMemory("getUniform: Out of memory.");
                return JS::NullValue();
            }
            return val;
        }

    case LOCAL_GL_FLOAT:
    case LOCAL_GL_FLOAT_VEC2:
    case LOCAL_GL_FLOAT_VEC3:
    case LOCAL_GL_FLOAT_VEC4:
    case LOCAL_GL_FLOAT_MAT2:
    case LOCAL_GL_FLOAT_MAT3:
    case LOCAL_GL_FLOAT_MAT4:
    case LOCAL_GL_FLOAT_MAT2x3:
    case LOCAL_GL_FLOAT_MAT2x4:
    case LOCAL_GL_FLOAT_MAT3x2:
    case LOCAL_GL_FLOAT_MAT3x4:
    case LOCAL_GL_FLOAT_MAT4x2:
    case LOCAL_GL_FLOAT_MAT4x3:
        {
            GLfloat buffer[16] = {0.0f};
            gl->fGetUniformfv(prog, mLoc, buffer);

            if (elemSize == 1)
                return JS::DoubleValue(buffer[0]);

            JSObject* obj = dom::Float32Array::Create(js, mContext, elemSize, buffer);
            if (!obj) {
                mContext->ErrorOutOfMemory("getUniform: Out of memory.");
                return JS::NullValue();
            }
            return JS::ObjectOrNullValue(obj);
        }

    case LOCAL_GL_UNSIGNED_INT:
    case LOCAL_GL_UNSIGNED_INT_VEC2:
    case LOCAL_GL_UNSIGNED_INT_VEC3:
    case LOCAL_GL_UNSIGNED_INT_VEC4:
        {
            GLuint buffer[kMaxElemSize] = {0};
            gl->fGetUniformuiv(prog, mLoc, buffer);

            if (elemSize == 1)
                return JS::DoubleValue(buffer[0]); // This is Double because only Int32 is special cased.

            JSObject* obj = dom::Uint32Array::Create(js, mContext, elemSize, buffer);
            if (!obj) {
                mContext->ErrorOutOfMemory("getUniform: Out of memory.");
                return JS::NullValue();
            }
            return JS::ObjectOrNullValue(obj);
        }

    default:
        MOZ_CRASH("GFX: Invalid elemType.");
    }
}

////////////////////////////////////////////////////////////////////////////////

JSObject*
WebGLUniformLocation::WrapObject(JSContext* js, JS::Handle<JSObject*> givenProto)
{
    return dom::WebGLUniformLocation_Binding::Wrap(js, this, givenProto);
}

NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(WebGLUniformLocation)

NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(WebGLUniformLocation, AddRef)
NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(WebGLUniformLocation, Release)

} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53

Line	Count	Source (jump to first uncovered line)
1		/* -- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -- */
2		/* This Source Code Form is subject to the terms of the Mozilla Public
3		* License, v. 2.0. If a copy of the MPL was not distributed with this
4		* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6		#include "WebGLUniformLocation.h"
7
8		#include "GLContext.h"
9		#include "mozilla/dom/ToJSValue.h"
10		#include "mozilla/dom/WebGLRenderingContextBinding.h"
11		#include "WebGLActiveInfo.h"
12		#include "WebGLContext.h"
13		#include "WebGLProgram.h"
14
15		namespace mozilla {
16
17		WebGLUniformLocation::WebGLUniformLocation(WebGLContext* webgl,
18		const webgl::LinkedProgramInfo* linkInfo,
19		webgl::UniformInfo* info, GLuint loc,
20		size_t arrayIndex)
21		: WebGLContextBoundObject(webgl)
22		, mLinkInfo(linkInfo)
23		, mInfo(info)
24		, mLoc(loc)
25		, mArrayIndex(arrayIndex)
26	0	{ }
27
28		WebGLUniformLocation::~WebGLUniformLocation()
29	0	{ }
30
31		bool
32		WebGLUniformLocation::ValidateForProgram(const WebGLProgram* prog) const
33	0	{
34	0	// Check the weak-pointer.
35	0	if (!mLinkInfo) {
36	0	mContext->ErrorInvalidOperation("This uniform location is obsolete because"
37	0	" its program has been successfully relinked.");
38	0	return false;
39	0	}
40	0
41	0	if (mLinkInfo->prog != prog) {
42	0	mContext->ErrorInvalidOperation("This uniform location corresponds to a"
43	0	" different program.");
44	0	return false;
45	0	}
46	0
47	0	return true;
48	0	}
49
50		static bool
51		IsUniformSetterTypeValid(GLenum setterType, GLenum uniformType)
52	0	{
53	0	// The order in this switch matches table 2.10 from OpenGL ES
54	0	// 3.0.4 (Aug 27, 2014) es_spec_3.0.4.pdf
55	0	switch (uniformType) {
56	0	case LOCAL_GL_FLOAT:
57	0	case LOCAL_GL_FLOAT_VEC2:
58	0	case LOCAL_GL_FLOAT_VEC3:
59	0	case LOCAL_GL_FLOAT_VEC4:
60	0	return setterType == LOCAL_GL_FLOAT;
61	0
62	0	case LOCAL_GL_INT:
63	0	case LOCAL_GL_INT_VEC2:
64	0	case LOCAL_GL_INT_VEC3:
65	0	case LOCAL_GL_INT_VEC4:
66	0	return setterType == LOCAL_GL_INT;
67	0
68	0	case LOCAL_GL_UNSIGNED_INT:
69	0	case LOCAL_GL_UNSIGNED_INT_VEC2:
70	0	case LOCAL_GL_UNSIGNED_INT_VEC3:
71	0	case LOCAL_GL_UNSIGNED_INT_VEC4:
72	0	return setterType == LOCAL_GL_UNSIGNED_INT;
73	0
74	0	/* bool can be set via any function: 0, 0.0f -> FALSE, _ -> TRUE */
75	0	case LOCAL_GL_BOOL:
76	0	case LOCAL_GL_BOOL_VEC2:
77	0	case LOCAL_GL_BOOL_VEC3:
78	0	case LOCAL_GL_BOOL_VEC4:
79	0	return (setterType == LOCAL_GL_INT \|\|
80	0	setterType == LOCAL_GL_FLOAT \|\|
81	0	setterType == LOCAL_GL_UNSIGNED_INT);
82	0
83	0	case LOCAL_GL_FLOAT_MAT2:
84	0	case LOCAL_GL_FLOAT_MAT3:
85	0	case LOCAL_GL_FLOAT_MAT4:
86	0	case LOCAL_GL_FLOAT_MAT2x3:
87	0	case LOCAL_GL_FLOAT_MAT2x4:
88	0	case LOCAL_GL_FLOAT_MAT3x2:
89	0	case LOCAL_GL_FLOAT_MAT3x4:
90	0	case LOCAL_GL_FLOAT_MAT4x2:
91	0	case LOCAL_GL_FLOAT_MAT4x3:
92	0	return setterType == LOCAL_GL_FLOAT;
93	0
94	0	/* Samplers can only be set via Uniform1i */
95	0	case LOCAL_GL_SAMPLER_2D:
96	0	case LOCAL_GL_SAMPLER_3D:
97	0	case LOCAL_GL_SAMPLER_CUBE:
98	0	case LOCAL_GL_SAMPLER_2D_SHADOW:
99	0	case LOCAL_GL_SAMPLER_2D_ARRAY:
100	0	case LOCAL_GL_SAMPLER_2D_ARRAY_SHADOW:
101	0	case LOCAL_GL_SAMPLER_CUBE_SHADOW:
102	0
103	0	case LOCAL_GL_INT_SAMPLER_2D:
104	0	case LOCAL_GL_INT_SAMPLER_3D:
105	0	case LOCAL_GL_INT_SAMPLER_CUBE:
106	0	case LOCAL_GL_INT_SAMPLER_2D_ARRAY:
107	0
108	0	case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D:
109	0	case LOCAL_GL_UNSIGNED_INT_SAMPLER_3D:
110	0	case LOCAL_GL_UNSIGNED_INT_SAMPLER_CUBE:
111	0	case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
112	0	return setterType == LOCAL_GL_INT;
113	0
114	0	default:
115	0	MOZ_CRASH("GFX: Bad `uniformType`.");
116	0	}
117	0	}
118
119		bool
120		WebGLUniformLocation::ValidateSizeAndType(uint8_t setterElemSize, GLenum setterType) const
121	0	{
122	0	MOZ_ASSERT(mLinkInfo);
123	0
124	0	const auto& uniformElemSize = mInfo->mActiveInfo->mElemSize;
125	0	if (setterElemSize != uniformElemSize) {
126	0	mContext->ErrorInvalidOperation("Function used differs from uniform size: %i",
127	0	uniformElemSize);
128	0	return false;
129	0	}
130	0
131	0	const auto& uniformElemType = mInfo->mActiveInfo->mElemType;
132	0	if (!IsUniformSetterTypeValid(setterType, uniformElemType)) {
133	0	mContext->ErrorInvalidOperation("Function used is incompatible with uniform"
134	0	" type: %i",
135	0	uniformElemType);
136	0	return false;
137	0	}
138	0
139	0	return true;
140	0	}
141
142		bool
143		WebGLUniformLocation::ValidateArrayLength(uint8_t setterElemSize,
144		size_t setterArraySize) const
145	0	{
146	0	MOZ_ASSERT(mLinkInfo);
147	0
148	0	if (setterArraySize == 0 \|\|
149	0	setterArraySize % setterElemSize)
150	0	{
151	0	mContext->ErrorInvalidValue("Expected an array of length a multiple of %d,"
152	0	" got an array of length %zu.",
153	0	setterElemSize, setterArraySize);
154	0	return false;
155	0	}
156	0
157	0	/* GLES 2.0.25, Section 2.10, p38
158	0	* When loading `N` elements starting at an arbitrary position `k` in a uniform
159	0	* declared as an array, elements `k` through `k + N - 1` in the array will be
160	0	* replaced with the new values. Values for any array element that exceeds the
161	0	* highest array element index used, as reported by `GetActiveUniform`, will be
162	0	* ignored by GL.
163	0	*/
164	0	if (!mInfo->mActiveInfo->mIsArray &&
165	0	setterArraySize != setterElemSize)
166	0	{
167	0	mContext->ErrorInvalidOperation("Expected an array of length exactly %d"
168	0	" (since this uniform is not an array uniform),"
169	0	" got an array of length %zu.",
170	0	setterElemSize, setterArraySize);
171	0	return false;
172	0	}
173	0
174	0	return true;
175	0	}
176
177		JS::Value
178		WebGLUniformLocation::GetUniform(JSContext* js) const
179	0	{
180	0	MOZ_ASSERT(mLinkInfo);
181	0
182	0	const uint8_t elemSize = mInfo->mActiveInfo->mElemSize;
183	0	static const uint8_t kMaxElemSize = 16;
184	0	MOZ_ASSERT(elemSize <= kMaxElemSize);
185	0
186	0	GLuint prog = mLinkInfo->prog->mGLName;
187	0
188	0	gl::GLContext* gl = mContext->GL();
189	0
190	0	switch (mInfo->mActiveInfo->mElemType) {
191	0	case LOCAL_GL_INT:
192	0	case LOCAL_GL_INT_VEC2:
193	0	case LOCAL_GL_INT_VEC3:
194	0	case LOCAL_GL_INT_VEC4:
195	0	case LOCAL_GL_SAMPLER_2D:
196	0	case LOCAL_GL_SAMPLER_3D:
197	0	case LOCAL_GL_SAMPLER_CUBE:
198	0	case LOCAL_GL_SAMPLER_2D_SHADOW:
199	0	case LOCAL_GL_SAMPLER_2D_ARRAY:
200	0	case LOCAL_GL_SAMPLER_2D_ARRAY_SHADOW:
201	0	case LOCAL_GL_SAMPLER_CUBE_SHADOW:
202	0	case LOCAL_GL_INT_SAMPLER_2D:
203	0	case LOCAL_GL_INT_SAMPLER_3D:
204	0	case LOCAL_GL_INT_SAMPLER_CUBE:
205	0	case LOCAL_GL_INT_SAMPLER_2D_ARRAY:
206	0	case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D:
207	0	case LOCAL_GL_UNSIGNED_INT_SAMPLER_3D:
208	0	case LOCAL_GL_UNSIGNED_INT_SAMPLER_CUBE:
209	0	case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
210	0	{
211	0	GLint buffer[kMaxElemSize] = {0};
212	0	gl->fGetUniformiv(prog, mLoc, buffer);
213	0
214	0	if (elemSize == 1)
215	0	return JS::Int32Value(buffer[0]);
216	0
217	0	JSObject* obj = dom::Int32Array::Create(js, mContext, elemSize, buffer);
218	0	if (!obj) {
219	0	mContext->ErrorOutOfMemory("getUniform: Out of memory.");
220	0	return JS::NullValue();
221	0	}
222	0	return JS::ObjectOrNullValue(obj);
223	0	}
224	0
225	0	case LOCAL_GL_BOOL:
226	0	case LOCAL_GL_BOOL_VEC2:
227	0	case LOCAL_GL_BOOL_VEC3:
228	0	case LOCAL_GL_BOOL_VEC4:
229	0	{
230	0	GLint buffer[kMaxElemSize] = {0};
231	0	gl->fGetUniformiv(prog, mLoc, buffer);
232	0
233	0	if (elemSize == 1)
234	0	return JS::BooleanValue(buffer[0]);
235	0
236	0	bool boolBuffer[kMaxElemSize];
237	0	for (uint8_t i = 0; i < kMaxElemSize; i++)
238	0	boolBuffer[i] = buffer[i];
239	0
240	0	JS::RootedValue val(js);
241	0	// Be careful: we don't want to convert all of \|uv\|!
242	0	if (!dom::ToJSValue(js, boolBuffer, elemSize, &val)) {
243	0	mContext->ErrorOutOfMemory("getUniform: Out of memory.");
244	0	return JS::NullValue();
245	0	}
246	0	return val;
247	0	}
248	0
249	0	case LOCAL_GL_FLOAT:
250	0	case LOCAL_GL_FLOAT_VEC2:
251	0	case LOCAL_GL_FLOAT_VEC3:
252	0	case LOCAL_GL_FLOAT_VEC4:
253	0	case LOCAL_GL_FLOAT_MAT2:
254	0	case LOCAL_GL_FLOAT_MAT3:
255	0	case LOCAL_GL_FLOAT_MAT4:
256	0	case LOCAL_GL_FLOAT_MAT2x3:
257	0	case LOCAL_GL_FLOAT_MAT2x4:
258	0	case LOCAL_GL_FLOAT_MAT3x2:
259	0	case LOCAL_GL_FLOAT_MAT3x4:
260	0	case LOCAL_GL_FLOAT_MAT4x2:
261	0	case LOCAL_GL_FLOAT_MAT4x3:
262	0	{
263	0	GLfloat buffer[16] = {0.0f};
264	0	gl->fGetUniformfv(prog, mLoc, buffer);
265	0
266	0	if (elemSize == 1)
267	0	return JS::DoubleValue(buffer[0]);
268	0
269	0	JSObject* obj = dom::Float32Array::Create(js, mContext, elemSize, buffer);
270	0	if (!obj) {
271	0	mContext->ErrorOutOfMemory("getUniform: Out of memory.");
272	0	return JS::NullValue();
273	0	}
274	0	return JS::ObjectOrNullValue(obj);
275	0	}
276	0
277	0	case LOCAL_GL_UNSIGNED_INT:
278	0	case LOCAL_GL_UNSIGNED_INT_VEC2:
279	0	case LOCAL_GL_UNSIGNED_INT_VEC3:
280	0	case LOCAL_GL_UNSIGNED_INT_VEC4:
281	0	{
282	0	GLuint buffer[kMaxElemSize] = {0};
283	0	gl->fGetUniformuiv(prog, mLoc, buffer);
284	0
285	0	if (elemSize == 1)
286	0	return JS::DoubleValue(buffer[0]); // This is Double because only Int32 is special cased.
287	0
288	0	JSObject* obj = dom::Uint32Array::Create(js, mContext, elemSize, buffer);
289	0	if (!obj) {
290	0	mContext->ErrorOutOfMemory("getUniform: Out of memory.");
291	0	return JS::NullValue();
292	0	}
293	0	return JS::ObjectOrNullValue(obj);
294	0	}
295	0
296	0	default:
297	0	MOZ_CRASH("GFX: Invalid elemType.");
298	0	}
299	0	}
300
301		////////////////////////////////////////////////////////////////////////////////
302
303		JSObject*
304		WebGLUniformLocation::WrapObject(JSContext* js, JS::Handle<JSObject*> givenProto)
305	0	{
306	0	return dom::WebGLUniformLocation_Binding::Wrap(js, this, givenProto);
307	0	}
308
309		NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(WebGLUniformLocation)
310
311		NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(WebGLUniformLocation, AddRef)
312		NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(WebGLUniformLocation, Release)
313
314		} // namespace mozilla