зеркало из https://github.com/mozilla/gecko-dev.git
426 строки
12 KiB
C++
426 строки
12 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* 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 "WebGLContext.h"
|
|
|
|
#include "GLContext.h"
|
|
#include "mozilla/Casting.h"
|
|
#include "mozilla/CheckedInt.h"
|
|
#include "WebGLBuffer.h"
|
|
#include "WebGLFramebuffer.h"
|
|
#include "WebGLProgram.h"
|
|
#include "WebGLRenderbuffer.h"
|
|
#include "WebGLShader.h"
|
|
#include "WebGLTexture.h"
|
|
#include "WebGLVertexArray.h"
|
|
#include "WebGLVertexAttribData.h"
|
|
|
|
#include "mozilla/Casting.h"
|
|
|
|
namespace mozilla {
|
|
|
|
static bool ValidateAttribIndex(WebGLContext& webgl, GLuint index) {
|
|
bool valid = (index < webgl.MaxVertexAttribs());
|
|
|
|
if (!valid) {
|
|
if (index == GLuint(-1)) {
|
|
webgl.ErrorInvalidValue(
|
|
"-1 is not a valid `index`. This value"
|
|
" probably comes from a getAttribLocation()"
|
|
" call, where this return value -1 means"
|
|
" that the passed name didn't correspond to"
|
|
" an active attribute in the specified"
|
|
" program.");
|
|
} else {
|
|
webgl.ErrorInvalidValue(
|
|
"`index` must be less than"
|
|
" MAX_VERTEX_ATTRIBS.");
|
|
}
|
|
}
|
|
|
|
return valid;
|
|
}
|
|
|
|
JSObject* WebGLContext::GetVertexAttribFloat32Array(JSContext* cx,
|
|
GLuint index) {
|
|
GLfloat attrib[4];
|
|
if (index) {
|
|
gl->fGetVertexAttribfv(index, LOCAL_GL_CURRENT_VERTEX_ATTRIB, attrib);
|
|
} else {
|
|
memcpy(attrib, mGenericVertexAttrib0Data,
|
|
sizeof(mGenericVertexAttrib0Data));
|
|
}
|
|
return dom::Float32Array::Create(cx, this, 4, attrib);
|
|
}
|
|
|
|
JSObject* WebGLContext::GetVertexAttribInt32Array(JSContext* cx, GLuint index) {
|
|
GLint attrib[4];
|
|
if (index) {
|
|
gl->fGetVertexAttribIiv(index, LOCAL_GL_CURRENT_VERTEX_ATTRIB, attrib);
|
|
} else {
|
|
memcpy(attrib, mGenericVertexAttrib0Data,
|
|
sizeof(mGenericVertexAttrib0Data));
|
|
}
|
|
return dom::Int32Array::Create(cx, this, 4, attrib);
|
|
}
|
|
|
|
JSObject* WebGLContext::GetVertexAttribUint32Array(JSContext* cx,
|
|
GLuint index) {
|
|
GLuint attrib[4];
|
|
if (index) {
|
|
gl->fGetVertexAttribIuiv(index, LOCAL_GL_CURRENT_VERTEX_ATTRIB, attrib);
|
|
} else {
|
|
memcpy(attrib, mGenericVertexAttrib0Data,
|
|
sizeof(mGenericVertexAttrib0Data));
|
|
}
|
|
return dom::Uint32Array::Create(cx, this, 4, attrib);
|
|
}
|
|
|
|
////////////////////////////////////////
|
|
|
|
void WebGLContext::VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z,
|
|
GLfloat w) {
|
|
const FuncScope funcScope(*this, "vertexAttrib4f");
|
|
if (IsContextLost()) return;
|
|
|
|
if (!ValidateAttribIndex(*this, index)) return;
|
|
|
|
////
|
|
|
|
if (index || !gl->IsCompatibilityProfile()) {
|
|
gl->fVertexAttrib4f(index, x, y, z, w);
|
|
}
|
|
|
|
////
|
|
|
|
mGenericVertexAttribTypes[index] = webgl::AttribBaseType::Float;
|
|
mGenericVertexAttribTypeInvalidator.InvalidateCaches();
|
|
|
|
if (!index) {
|
|
const float data[4] = {x, y, z, w};
|
|
memcpy(mGenericVertexAttrib0Data, data, sizeof(data));
|
|
}
|
|
}
|
|
|
|
void WebGL2Context::VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z,
|
|
GLint w) {
|
|
const FuncScope funcScope(*this, "vertexAttribI4i");
|
|
if (IsContextLost()) return;
|
|
|
|
if (!ValidateAttribIndex(*this, index)) return;
|
|
|
|
////
|
|
|
|
if (index || !gl->IsCompatibilityProfile()) {
|
|
gl->fVertexAttribI4i(index, x, y, z, w);
|
|
}
|
|
|
|
////
|
|
|
|
mGenericVertexAttribTypes[index] = webgl::AttribBaseType::Int;
|
|
mGenericVertexAttribTypeInvalidator.InvalidateCaches();
|
|
|
|
if (!index) {
|
|
const int32_t data[4] = {x, y, z, w};
|
|
memcpy(mGenericVertexAttrib0Data, data, sizeof(data));
|
|
}
|
|
}
|
|
|
|
void WebGL2Context::VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z,
|
|
GLuint w) {
|
|
const FuncScope funcScope(*this, "vertexAttribI4ui");
|
|
if (IsContextLost()) return;
|
|
|
|
if (!ValidateAttribIndex(*this, index)) return;
|
|
|
|
////
|
|
|
|
if (index || !gl->IsCompatibilityProfile()) {
|
|
gl->fVertexAttribI4ui(index, x, y, z, w);
|
|
}
|
|
|
|
////
|
|
|
|
mGenericVertexAttribTypes[index] = webgl::AttribBaseType::UInt;
|
|
mGenericVertexAttribTypeInvalidator.InvalidateCaches();
|
|
|
|
if (!index) {
|
|
const uint32_t data[4] = {x, y, z, w};
|
|
memcpy(mGenericVertexAttrib0Data, data, sizeof(data));
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////
|
|
|
|
void WebGLContext::EnableVertexAttribArray(GLuint index) {
|
|
const FuncScope funcScope(*this, "enableVertexAttribArray");
|
|
if (IsContextLost()) return;
|
|
|
|
if (!ValidateAttribIndex(*this, index)) return;
|
|
|
|
gl->fEnableVertexAttribArray(index);
|
|
|
|
MOZ_ASSERT(mBoundVertexArray);
|
|
mBoundVertexArray->mAttribs[index].mEnabled = true;
|
|
mBoundVertexArray->InvalidateCaches();
|
|
}
|
|
|
|
void WebGLContext::DisableVertexAttribArray(GLuint index) {
|
|
const FuncScope funcScope(*this, "disableVertexAttribArray");
|
|
if (IsContextLost()) return;
|
|
|
|
if (!ValidateAttribIndex(*this, index)) return;
|
|
|
|
if (index || !gl->IsCompatibilityProfile()) {
|
|
gl->fDisableVertexAttribArray(index);
|
|
}
|
|
|
|
MOZ_ASSERT(mBoundVertexArray);
|
|
mBoundVertexArray->mAttribs[index].mEnabled = false;
|
|
mBoundVertexArray->InvalidateCaches();
|
|
}
|
|
|
|
JS::Value WebGLContext::GetVertexAttrib(JSContext* cx, GLuint index,
|
|
GLenum pname, ErrorResult& rv) {
|
|
const FuncScope funcScope(*this, "getVertexAttrib");
|
|
if (IsContextLost()) return JS::NullValue();
|
|
|
|
if (!ValidateAttribIndex(*this, index)) return JS::NullValue();
|
|
|
|
MOZ_ASSERT(mBoundVertexArray);
|
|
|
|
switch (pname) {
|
|
case LOCAL_GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
|
|
return WebGLObjectAsJSValue(
|
|
cx, mBoundVertexArray->mAttribs[index].mBuf.get(), rv);
|
|
|
|
case LOCAL_GL_VERTEX_ATTRIB_ARRAY_STRIDE:
|
|
return JS::Int32Value(mBoundVertexArray->mAttribs[index].Stride());
|
|
|
|
case LOCAL_GL_VERTEX_ATTRIB_ARRAY_SIZE:
|
|
return JS::Int32Value(mBoundVertexArray->mAttribs[index].Size());
|
|
|
|
case LOCAL_GL_VERTEX_ATTRIB_ARRAY_TYPE:
|
|
return JS::Int32Value(mBoundVertexArray->mAttribs[index].Type());
|
|
|
|
case LOCAL_GL_VERTEX_ATTRIB_ARRAY_INTEGER:
|
|
if (IsWebGL2())
|
|
return JS::BooleanValue(
|
|
mBoundVertexArray->mAttribs[index].IntegerFunc());
|
|
|
|
break;
|
|
|
|
case LOCAL_GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
|
|
if (IsWebGL2() ||
|
|
IsExtensionEnabled(WebGLExtensionID::ANGLE_instanced_arrays)) {
|
|
return JS::Int32Value(mBoundVertexArray->mAttribs[index].mDivisor);
|
|
}
|
|
break;
|
|
|
|
case LOCAL_GL_CURRENT_VERTEX_ATTRIB: {
|
|
JS::RootedObject obj(cx);
|
|
switch (mGenericVertexAttribTypes[index]) {
|
|
case webgl::AttribBaseType::Float:
|
|
obj = GetVertexAttribFloat32Array(cx, index);
|
|
break;
|
|
|
|
case webgl::AttribBaseType::Int:
|
|
obj = GetVertexAttribInt32Array(cx, index);
|
|
break;
|
|
|
|
case webgl::AttribBaseType::UInt:
|
|
obj = GetVertexAttribUint32Array(cx, index);
|
|
break;
|
|
|
|
case webgl::AttribBaseType::Boolean:
|
|
MOZ_CRASH("impossible");
|
|
}
|
|
|
|
if (!obj) {
|
|
rv.Throw(NS_ERROR_OUT_OF_MEMORY);
|
|
return JS::NullValue();
|
|
}
|
|
return JS::ObjectValue(*obj);
|
|
}
|
|
|
|
case LOCAL_GL_VERTEX_ATTRIB_ARRAY_ENABLED:
|
|
return JS::BooleanValue(mBoundVertexArray->mAttribs[index].mEnabled);
|
|
|
|
case LOCAL_GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
|
|
return JS::BooleanValue(mBoundVertexArray->mAttribs[index].Normalized());
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
ErrorInvalidEnumInfo("pname", pname);
|
|
return JS::NullValue();
|
|
}
|
|
|
|
WebGLsizeiptr WebGLContext::GetVertexAttribOffset(GLuint index, GLenum pname) {
|
|
const FuncScope funcScope(*this, "getVertexAttribOffset");
|
|
if (IsContextLost()) return 0;
|
|
|
|
if (!ValidateAttribIndex(*this, index)) return 0;
|
|
|
|
if (pname != LOCAL_GL_VERTEX_ATTRIB_ARRAY_POINTER) {
|
|
ErrorInvalidEnum("`pname` must be VERTEX_ATTRIB_ARRAY_POINTER.");
|
|
return 0;
|
|
}
|
|
|
|
MOZ_ASSERT(mBoundVertexArray);
|
|
return mBoundVertexArray->mAttribs[index].ByteOffset();
|
|
}
|
|
|
|
////////////////////////////////////////
|
|
|
|
void WebGLContext::VertexAttribAnyPointer(bool isFuncInt, GLuint index,
|
|
GLint size, GLenum type,
|
|
bool normalized, GLsizei stride,
|
|
WebGLintptr byteOffset) {
|
|
if (IsContextLost()) return;
|
|
|
|
if (!ValidateAttribIndex(*this, index)) return;
|
|
|
|
////
|
|
|
|
if (size < 1 || size > 4) {
|
|
ErrorInvalidValue("Invalid element size.");
|
|
return;
|
|
}
|
|
|
|
// see WebGL spec section 6.6 "Vertex Attribute Data Stride"
|
|
if (stride < 0 || stride > 255) {
|
|
ErrorInvalidValue("Negative or too large stride.");
|
|
return;
|
|
}
|
|
|
|
if (byteOffset < 0) {
|
|
ErrorInvalidValue("Negative offset.");
|
|
return;
|
|
}
|
|
|
|
////
|
|
|
|
bool isTypeValid = true;
|
|
uint8_t typeAlignment;
|
|
switch (type) {
|
|
// WebGL 1:
|
|
case LOCAL_GL_BYTE:
|
|
case LOCAL_GL_UNSIGNED_BYTE:
|
|
typeAlignment = 1;
|
|
break;
|
|
|
|
case LOCAL_GL_SHORT:
|
|
case LOCAL_GL_UNSIGNED_SHORT:
|
|
typeAlignment = 2;
|
|
break;
|
|
|
|
case LOCAL_GL_FLOAT:
|
|
if (isFuncInt) {
|
|
isTypeValid = false;
|
|
}
|
|
typeAlignment = 4;
|
|
break;
|
|
|
|
// WebGL 2:
|
|
case LOCAL_GL_INT:
|
|
case LOCAL_GL_UNSIGNED_INT:
|
|
if (!IsWebGL2()) {
|
|
isTypeValid = false;
|
|
}
|
|
typeAlignment = 4;
|
|
break;
|
|
|
|
case LOCAL_GL_HALF_FLOAT:
|
|
if (isFuncInt || !IsWebGL2()) {
|
|
isTypeValid = false;
|
|
}
|
|
typeAlignment = 2;
|
|
break;
|
|
|
|
case LOCAL_GL_FIXED:
|
|
if (isFuncInt || !IsWebGL2()) {
|
|
isTypeValid = false;
|
|
}
|
|
typeAlignment = 4;
|
|
break;
|
|
|
|
case LOCAL_GL_INT_2_10_10_10_REV:
|
|
case LOCAL_GL_UNSIGNED_INT_2_10_10_10_REV:
|
|
if (isFuncInt || !IsWebGL2()) {
|
|
isTypeValid = false;
|
|
break;
|
|
}
|
|
if (size != 4) {
|
|
ErrorInvalidOperation("Size must be 4 for this type.");
|
|
return;
|
|
}
|
|
typeAlignment = 4;
|
|
break;
|
|
|
|
default:
|
|
isTypeValid = false;
|
|
break;
|
|
}
|
|
if (!isTypeValid) {
|
|
ErrorInvalidEnumInfo("type", type);
|
|
return;
|
|
}
|
|
|
|
////
|
|
|
|
// `alignment` should always be a power of two.
|
|
MOZ_ASSERT(IsPowerOfTwo(typeAlignment));
|
|
const GLsizei typeAlignmentMask = typeAlignment - 1;
|
|
|
|
if (stride & typeAlignmentMask || byteOffset & typeAlignmentMask) {
|
|
ErrorInvalidOperation(
|
|
"`stride` and `byteOffset` must satisfy the alignment"
|
|
" requirement of `type`.");
|
|
return;
|
|
}
|
|
|
|
////
|
|
|
|
const auto& buffer = mBoundArrayBuffer;
|
|
if (!buffer && byteOffset) {
|
|
ErrorInvalidOperation("If ARRAY_BUFFER is null, byteOffset must be zero.");
|
|
return;
|
|
}
|
|
|
|
////
|
|
|
|
if (isFuncInt) {
|
|
gl->fVertexAttribIPointer(index, size, type, stride,
|
|
reinterpret_cast<void*>(byteOffset));
|
|
} else {
|
|
gl->fVertexAttribPointer(index, size, type, normalized, stride,
|
|
reinterpret_cast<void*>(byteOffset));
|
|
}
|
|
|
|
WebGLVertexAttribData& vd = mBoundVertexArray->mAttribs[index];
|
|
vd.VertexAttribPointer(isFuncInt, buffer, AutoAssertCast(size), type,
|
|
normalized, stride, byteOffset);
|
|
mBoundVertexArray->InvalidateCaches();
|
|
}
|
|
|
|
////////////////////////////////////////
|
|
|
|
void WebGLContext::VertexAttribDivisor(GLuint index, GLuint divisor) {
|
|
const FuncScope funcScope(*this, "vertexAttribDivisor");
|
|
if (IsContextLost()) return;
|
|
|
|
if (!ValidateAttribIndex(*this, index)) return;
|
|
|
|
MOZ_ASSERT(mBoundVertexArray);
|
|
mBoundVertexArray->mAttribs[index].mDivisor = divisor;
|
|
mBoundVertexArray->InvalidateCaches();
|
|
|
|
gl->fVertexAttribDivisor(index, divisor);
|
|
}
|
|
|
|
} // namespace mozilla
|