void eFBCTunerManager::Unlink(eDVBRegisteredFrontend *fe) const
{
eDVBRegisteredFrontend *simul_fe;
bool simulate;
simulate = fe->m_frontend->is_simulate();
if (IsRootFE(fe) || IsFEUsed(fe, simulate) || IsSCR(fe) || !IsLinked(fe))
return;
//PrintLinks(fe);
DisconnectLink(fe, FrontendGetLinkPtr(fe, link_prev), FrontendGetLinkPtr(fe, link_next), simulate);
fe->m_frontend->setEnabled(false);
if(!simulate) // also act on the simulation frontends
{
if((simul_fe = GetSimulFE(fe)) && !IsRootFE(simul_fe) && !IsFEUsed(simul_fe, true) &&
!IsSCR(simul_fe) && IsLinked(simul_fe))
{
DisconnectLink(simul_fe, FrontendGetLinkPtr(simul_fe, link_prev), FrontendGetLinkPtr(simul_fe, link_next), true);
simul_fe->m_frontend->setEnabled(false);
}
}
//PrintLinks(fe);
//setDefaultFBCID(link_fe);
UpdateLNBSlotMask(FESlotID(fe), FESlotID(GetHead(fe)), /*remove*/true);
}
already_AddRefed<WebGLActiveInfo>
WebGLProgram::GetTransformFeedbackVarying(GLuint index)
{
// No docs in the WebGL 2 spec for this function. Taking the language for
// getActiveAttrib, which states that the function returns null on any error.
if (!IsLinked()) {
mContext->ErrorInvalidOperation("getTransformFeedbackVarying: `program` must be "
"linked.");
return nullptr;
}
if (index >= mTransformFeedbackVaryings.size()) {
mContext->ErrorInvalidValue("getTransformFeedbackVarying: `index` is greater or "
"equal to TRANSFORM_FEEDBACK_VARYINGS.");
return nullptr;
}
const nsCString& varyingUserName = mTransformFeedbackVaryings[index];
WebGLActiveInfo* info;
LinkInfo()->FindAttrib(varyingUserName, (const WebGLActiveInfo**) &info);
MOZ_ASSERT(info);
RefPtr<WebGLActiveInfo> ret(info);
return ret.forget();
}
CampaignTime SimPersistantClass::RemovalTime (void)
{
if (IsLinked())
return 0xffffffff;
else
return unionData.removeTime;
}
bool BaseProgramRenderPass::Initialize()
{
if (mProgramState->Program()!=0)
{
Uninitialize();
}
uint newProgram=Render::Instance().CreateProgram();
RETURN_FALSE_IF_ZERO(newProgram);
mProgramState->SetProgram(newProgram);
if (mVertexShader!=nullptr)
{
Render::Instance().AttachShader(newProgram,mVertexShader->Shader());
}
if (mPixelShader!=nullptr)
{
Render::Instance().AttachShader(newProgram,mPixelShader->Shader());
}
if (!IsLinked())
{
Link();
}
return true;
}
bool CResourceLink::ResourceLock( CResourceLock &s )
{
ADDTOCALLSTACK("CResourceLink::ResourceLock");
// Find the definition of this item in the scripts.
// Open a locked copy of this script
// NOTE: How can we tell the file has changed since last open ?
// RETURN: true = found it.
if ( !IsLinked() ) // has already failed previously.
return false;
ASSERT(m_pScript);
// Give several tryes to lock the script while multithreading
int iRet = s.OpenLock( m_pScript, m_Context );
if ( ! iRet )
return true;
s.AttachObj( this );
// ret = -2 or -3
lpctstr pszName = GetResourceName();
DEBUG_ERR(("ResourceLock '%s':%d id=%s FAILED\n", s.GetFilePath(), m_Context.m_iOffset, pszName));
return false;
}
bool ShaderProgram::Link()
{
if(mVertexShader != NULL && mFragmentShader != NULL)
{
if(mProgramId != 0)
{
glDetachShader(ProgramId(),mVertexShader->ShaderId());
glDetachShader(ProgramId(),mFragmentShader->ShaderId());
glDeleteProgram(ProgramId());
}
//Create the shader program and attach the two shaders to it.
mProgramId = glCreateProgram();
glAttachShader(ProgramId(),mVertexShader->ShaderId());
glAttachShader(ProgramId(),mFragmentShader->ShaderId());
//Link the shader program
glLinkProgram(ProgramId());
return IsLinked();
}
else
{
return false;
}
}
void
WebGLProgram::UniformBlockBinding(GLuint uniformBlockIndex,
GLuint uniformBlockBinding) const
{
const char funcName[] = "getActiveUniformBlockName";
if (!IsLinked()) {
mContext->ErrorInvalidOperation("%s: `program` must be linked.", funcName);
return;
}
const auto& uniformBlocks = LinkInfo()->uniformBlocks;
if (uniformBlockIndex >= uniformBlocks.size()) {
mContext->ErrorInvalidValue("%s: Index %u invalid.", funcName, uniformBlockIndex);
return;
}
const auto& uniformBlock = uniformBlocks[uniformBlockIndex];
const auto& indexedBindings = mContext->mIndexedUniformBufferBindings;
if (uniformBlockBinding >= indexedBindings.size()) {
mContext->ErrorInvalidValue("%s: Binding %u invalid.", funcName,
uniformBlockBinding);
return;
}
const auto& indexedBinding = indexedBindings[uniformBlockBinding];
////
gl::GLContext* gl = mContext->GL();
gl->MakeCurrent();
gl->fUniformBlockBinding(mGLName, uniformBlockIndex, uniformBlockBinding);
////
uniformBlock->mBinding = &indexedBinding;
}
JS::Value
WebGLProgram::GetActiveUniformBlockParam(GLuint uniformBlockIndex, GLenum pname) const
{
if (!IsLinked()) {
mContext->ErrorInvalidOperation("getActiveUniformBlockParameter: `program` must be linked.");
return JS::NullValue();
}
const webgl::LinkedProgramInfo* linkInfo = LinkInfo();
GLuint uniformBlockCount = (GLuint)linkInfo->uniformBlocks.size();
if (uniformBlockIndex >= uniformBlockCount) {
mContext->ErrorInvalidValue("getActiveUniformBlockParameter: index %u invalid.", uniformBlockIndex);
return JS::NullValue();
}
gl::GLContext* gl = mContext->GL();
GLint param = 0;
switch (pname) {
case LOCAL_GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
case LOCAL_GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
gl->fGetActiveUniformBlockiv(mGLName, uniformBlockIndex, pname, ¶m);
return JS::BooleanValue(bool(param));
case LOCAL_GL_UNIFORM_BLOCK_BINDING:
case LOCAL_GL_UNIFORM_BLOCK_DATA_SIZE:
case LOCAL_GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
gl->fGetActiveUniformBlockiv(mGLName, uniformBlockIndex, pname, ¶m);
return JS::NumberValue(param);
default:
MOZ_CRASH("bad `pname`.");
}
}
void
WebGLProgram::GetActiveUniformBlockParam(GLuint uniformBlockIndex, GLenum pname,
dom::Nullable<dom::OwningUnsignedLongOrUint32ArrayOrBoolean>& retval) const
{
retval.SetNull();
if (!IsLinked()) {
mContext->ErrorInvalidOperation("getActiveUniformBlockParameter: `program` must be linked.");
return;
}
const webgl::LinkedProgramInfo* linkInfo = LinkInfo();
GLuint uniformBlockCount = (GLuint)linkInfo->uniformBlocks.size();
if (uniformBlockIndex >= uniformBlockCount) {
mContext->ErrorInvalidValue("getActiveUniformBlockParameter: index %u invalid.", uniformBlockIndex);
return;
}
gl::GLContext* gl = mContext->GL();
GLint param = 0;
switch (pname) {
case LOCAL_GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
case LOCAL_GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
gl->fGetActiveUniformBlockiv(mGLName, uniformBlockIndex, pname, ¶m);
retval.SetValue().SetAsBoolean() = (param != 0);
return;
case LOCAL_GL_UNIFORM_BLOCK_BINDING:
case LOCAL_GL_UNIFORM_BLOCK_DATA_SIZE:
case LOCAL_GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
gl->fGetActiveUniformBlockiv(mGLName, uniformBlockIndex, pname, ¶m);
retval.SetValue().SetAsUnsignedLong() = param;
return;
}
}
bool ProgramGLSL::IsValid()
{
// Get the OpenGL ES program - this also ensures that the program is linked
GetOpenGLESProgram();
// Is the OpenGL ES program linked?
return IsLinked();
}
//
// P_FindNextLowestFloor()
//
// Passed a sector and a floor height, returns the fixed point value
// of the largest floor height in a surrounding sector smaller than
// the floor height passed. If no such height exists the floorheight
// passed is returned.
//
// jff 02/03/98 Twiddled Lee's P_FindNextHighestFloor to make this
//
fixed_t sector_t::FindNextLowestFloor (vertex_t **v) const
{
fixed_t height;
fixed_t heightdiff;
fixed_t ofloor, floor;
sector_t *other;
vertex_t *spot;
line_t *check;
int i;
if (linecount == 0) return GetPlaneTexZ(sector_t::floor);
spot = lines[0]->v1;
height = floorplane.ZatPoint (spot);
heightdiff = FIXED_MAX;
for (i = 0; i < linecount; i++)
{
check = lines[i];
if (NULL != (other = getNextSector (check, this)))
{
if (other - sectors == 6)
other = other;
ofloor = other->floorplane.ZatPoint (check->v1);
floor = floorplane.ZatPoint (check->v1);
if (ofloor < floor && floor - ofloor < heightdiff && !IsLinked(other, false))
{
heightdiff = floor - ofloor;
height = ofloor;
spot = check->v1;
}
ofloor = other->floorplane.ZatPoint (check->v2);
floor = floorplane.ZatPoint (check->v2);
if (ofloor < floor && floor - ofloor < heightdiff && !IsLinked(other, false))
{
heightdiff = floor - ofloor;
height = ofloor;
spot = check->v2;
}
}
}
if (v != NULL)
*v = spot;
return height;
}
int eFBCTunerManager::IsCompatibleWith(ePtr<iDVBFrontendParameters> &feparm, eDVBRegisteredFrontend *link_fe, eDVBRegisteredFrontend *&fbc_fe, bool simulate) const
{
eSmartPtrList<eDVBRegisteredFrontend> &frontends = simulate ? m_res_mgr->m_simulate_frontend : m_res_mgr->m_frontend;
eDVBRegisteredFrontend *fe_insert_point;
int best_score, new_score;
best_score = 0;
for (eSmartPtrList<eDVBRegisteredFrontend>::iterator it(frontends.begin()); it != frontends.end(); ++it)
{
if (!it->m_frontend->is_FBCTuner())
continue;
if (!IsRootFE(*it))
continue;
if(!it->m_frontend->getEnabled())
continue;
if(!IsSameFBCSet(FESlotID(link_fe), FESlotID(it)))
continue;
if(it->m_inuse == 0)
continue;
if(IsLinked(*it))
continue;
if(IsSCR(*it))
continue;
// temporarily add this leaf to the current "linked" chain, at the tail
fe_insert_point = GetTail(*it);
ConnectLink(link_fe, /*prev_fe*/fe_insert_point, /*next_fe*/(eDVBRegisteredFrontend *)0, simulate);
link_fe->m_frontend->setEnabled(true);
UpdateLNBSlotMask(FESlotID(link_fe), FESlotID(*it), false);
// get score when leaf is added
new_score = link_fe->m_frontend->isCompatibleWith(feparm);
if (new_score > best_score)
{
best_score = new_score;
fbc_fe = *it;
}
// now remove the leaf tuner again
DisconnectLink(link_fe, /*prev_fe*/fe_insert_point, /*next_fe*/(eDVBRegisteredFrontend *)0, simulate);
link_fe->m_frontend->setEnabled(false);
UpdateLNBSlotMask(FESlotID(link_fe), FESlotID(*it), true);
}
return best_score;
}
void Program::Use() const
{
assert(IsLinked());
if (msCurrentlyInUse != mProgram)
{
msCurrentlyInUse = mProgram;
glUseProgram(mProgram);
}
}
//
// P_FindNextLowestCeiling()
//
// Passed a sector and a ceiling height, returns the fixed point value
// of the largest ceiling height in a surrounding sector smaller than
// the ceiling height passed. If no such height exists the ceiling height
// passed is returned.
//
// jff 02/03/98 Twiddled Lee's P_FindNextHighestFloor to make this
//
fixed_t sector_t::FindNextLowestCeiling (vertex_t **v) const
{
fixed_t height;
fixed_t heightdiff;
fixed_t oceil, ceil;
sector_t *other;
vertex_t *spot;
line_t *check;
int i;
if (linecount == 0) return GetPlaneTexZ(sector_t::ceiling);
spot = lines[0]->v1;
height = ceilingplane.ZatPoint (spot);
heightdiff = FIXED_MAX;
for (i = 0; i < linecount; i++)
{
check = lines[i];
if (NULL != (other = getNextSector (check, this)))
{
oceil = other->ceilingplane.ZatPoint (check->v1);
ceil = ceilingplane.ZatPoint (check->v1);
if (oceil < ceil && ceil - oceil < heightdiff && !IsLinked(other, true))
{
heightdiff = ceil - oceil;
height = oceil;
spot = check->v1;
}
oceil = other->ceilingplane.ZatPoint (check->v2);
ceil = ceilingplane.ZatPoint (check->v2);
if (oceil < ceil && ceil - oceil < heightdiff && !IsLinked(other, true))
{
heightdiff = ceil - oceil;
height = oceil;
spot = check->v2;
}
}
}
if (v != NULL)
*v = spot;
return height;
}
NS_IMETHODIMP
nsHTMLLinkAccessible::GetNumActions(PRUint8 *aNumActions)
{
NS_ENSURE_ARG_POINTER(aNumActions);
if (!IsLinked())
return nsHyperTextAccessible::GetNumActions(aNumActions);
*aNumActions = 1;
return NS_OK;
}
/*
* Add a node after this node.
*/
void CListNode::AddAfter(CListNode &lnToAdd)
{
ASSERT(IsLinked() && !lnToAdd.IsLinked());
CListNode &succ = IterationSucc();
CListNode &pred = *this;
succ.ln_Pred = &lnToAdd;
pred.ln_Succ = &lnToAdd;
lnToAdd.ln_Succ = ≻
lnToAdd.ln_Pred = &pred;
}
/*
* Add a node before this node.
*/
void CListNode::AddBefore(CListNode &lnToAdd)
{
ASSERT(IsLinked() && !lnToAdd.IsLinked());
CListNode &succ = *this;
CListNode &pred = IterationPred();
succ.ln_Pred = &lnToAdd;
pred.ln_Succ = &lnToAdd;
lnToAdd.ln_Succ = ≻
lnToAdd.ln_Pred = &pred;
}
already_AddRefed<WebGLUniformLocation>
WebGLProgram::GetUniformLocation(const nsAString& userName_wide) const
{
if (!ValidateGLSLVariableName(userName_wide, mContext, "getUniformLocation"))
return nullptr;
if (!IsLinked()) {
mContext->ErrorInvalidOperation("getUniformLocation: `program` must be linked.");
return nullptr;
}
const NS_LossyConvertUTF16toASCII userName(userName_wide);
nsDependentCString baseUserName;
bool isArray = false;
// GLES 2.0.25, Section 2.10, p35
// If the the uniform location is an array, then the location of the first
// element of that array can be retrieved by either using the name of the
// uniform array, or the name of the uniform array appended with "[0]".
// The ParseName() can't recognize this rule. So always initialize
// arrayIndex with 0.
size_t arrayIndex = 0;
if (!ParseName(userName, &baseUserName, &isArray, &arrayIndex))
return nullptr;
const WebGLActiveInfo* activeInfo;
if (!LinkInfo()->FindUniform(baseUserName, &activeInfo))
return nullptr;
const nsCString& baseMappedName = activeInfo->mBaseMappedName;
nsAutoCString mappedName(baseMappedName);
if (isArray) {
mappedName.AppendLiteral("[");
mappedName.AppendInt(uint32_t(arrayIndex));
mappedName.AppendLiteral("]");
}
gl::GLContext* gl = mContext->GL();
gl->MakeCurrent();
GLint loc = gl->fGetUniformLocation(mGLName, mappedName.BeginReading());
if (loc == -1)
return nullptr;
RefPtr<WebGLUniformLocation> locObj = new WebGLUniformLocation(mContext, LinkInfo(),
loc, arrayIndex,
activeInfo);
return locObj.forget();
}
/*
* Remove a node from list.
*/
void CListNode::Remove(void)
{
ASSERT(IsLinked());
CListNode &next = *ln_Succ;
CListNode &prev = *ln_Pred;
ASSERT(next.IsTailMarker() || next.IsLinked());
ASSERT(prev.IsHeadMarker() || prev.IsLinked());
next.ln_Pred = &prev;
prev.ln_Succ = &next;
// make a non-linked node
ln_Succ = NULL;
ln_Pred = NULL;
}
NS_IMETHODIMP
nsHTMLLinkAccessible::GetActionName(PRUint8 aIndex, nsAString& aName)
{
aName.Truncate();
if (!IsLinked())
return nsHyperTextAccessible::GetActionName(aIndex, aName);
// Action 0 (default action): Jump to link
if (aIndex != eAction_Jump)
return NS_ERROR_INVALID_ARG;
aName.AssignLiteral("jump");
return NS_OK;
}
GLint Program::operator [](const std::string& uniform) const
{
assert(IsLinked());
if (mUniforms.find(uniform) != mUniforms.end())
return mUniforms.at(uniform);
else
{
GLint location = glGetUniformLocation(mProgram, uniform.c_str());
// assert(location != -1 && "Uniform not in shader");
if (location == -1)
Logger::Debug << "Uniform " << uniform << " location not found." << Logger::endl;
// else std::cout << "Uniform " << uniform << " location: " << location << std::endl;
mUniforms[uniform] = location;
return location;
}
}
NS_IMETHODIMP
nsHTMLLinkAccessible::DoAction(PRUint8 aIndex)
{
if (!IsLinked())
return nsHyperTextAccessible::DoAction(aIndex);
// Action 0 (default action): Jump to link
if (aIndex != eAction_Jump)
return NS_ERROR_INVALID_ARG;
if (IsDefunct())
return NS_ERROR_FAILURE;
DoCommand();
return NS_OK;
}
GLint Program::operator ()(const std::string& attribute) const
{
assert(IsLinked());
if (mAttributes.find(attribute) != mAttributes.end())
return mAttributes.at(attribute);
else
{
GLint location = glGetAttribLocation(mProgram, attribute.c_str());
// assert(location != -1 && "Uniform not in shader");
if (location == -1)
Logger::Debug << "Attribute " << attribute << " location not found." << Logger::endl;
// else std::cout << "Attribute " << attribute << " location: " << location << std::endl;
mAttributes[attribute] = location;
return location;
}
}
NS_IMETHODIMP
nsHTMLLinkAccessible::DoAction(PRUint8 aIndex)
{
if (!IsLinked())
return nsHyperTextAccessible::DoAction(aIndex);
// Action 0 (default action): Jump to link
if (aIndex != eAction_Jump)
return NS_ERROR_INVALID_ARG;
if (IsDefunct())
return NS_ERROR_FAILURE;
nsCOMPtr<nsIContent> content(do_QueryInterface(mDOMNode));
return DoCommand(content);
}
void
WebGLProgram::GetUniformIndices(const dom::Sequence<nsString>& uniformNames,
dom::Nullable< nsTArray<GLuint> >& retval) const
{
const char funcName[] = "getUniformIndices";
if (!IsLinked()) {
mContext->ErrorInvalidOperation("%s: `program` must be linked.", funcName);
return;
}
size_t count = uniformNames.Length();
nsTArray<GLuint>& arr = retval.SetValue();
gl::GLContext* gl = mContext->GL();
gl->MakeCurrent();
for (size_t i = 0; i < count; i++) {
const NS_LossyConvertUTF16toASCII userName(uniformNames[i]);
nsDependentCString baseUserName;
bool isArray;
size_t arrayIndex;
if (!ParseName(userName, &baseUserName, &isArray, &arrayIndex)) {
arr.AppendElement(LOCAL_GL_INVALID_INDEX);
continue;
}
webgl::UniformInfo* info;
if (!LinkInfo()->FindUniform(baseUserName, &info)) {
arr.AppendElement(LOCAL_GL_INVALID_INDEX);
continue;
}
nsAutoCString mappedName(info->mActiveInfo->mBaseMappedName);
if (isArray) {
mappedName.AppendLiteral("[");
mappedName.AppendInt(uint32_t(arrayIndex));
mappedName.AppendLiteral("]");
}
const GLchar* mappedNameBytes = mappedName.BeginReading();
GLuint index = 0;
gl->fGetUniformIndices(mGLName, 1, &mappedNameBytes, &index);
arr.AppendElement(index);
}
}
JS::Value
WebGLProgram::GetProgramParameter(GLenum pname) const
{
gl::GLContext* gl = mContext->gl;
gl->MakeCurrent();
if (mContext->IsWebGL2()) {
switch (pname) {
case LOCAL_GL_ACTIVE_UNIFORM_BLOCKS:
return JS::Int32Value(GetProgramiv(gl, mGLName, pname));
case LOCAL_GL_TRANSFORM_FEEDBACK_VARYINGS:
return JS::Int32Value(mNextLink_TransformFeedbackVaryings.size());
case LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
return JS::Int32Value(mNextLink_TransformFeedbackBufferMode);
}
}
switch (pname) {
case LOCAL_GL_ATTACHED_SHADERS:
case LOCAL_GL_ACTIVE_UNIFORMS:
case LOCAL_GL_ACTIVE_ATTRIBUTES:
return JS::Int32Value(GetProgramiv(gl, mGLName, pname));
case LOCAL_GL_DELETE_STATUS:
return JS::BooleanValue(IsDeleteRequested());
case LOCAL_GL_LINK_STATUS:
return JS::BooleanValue(IsLinked());
case LOCAL_GL_VALIDATE_STATUS:
#ifdef XP_MACOSX
// See comment in ValidateProgram.
if (gl->WorkAroundDriverBugs())
return JS::BooleanValue(true);
#endif
return JS::BooleanValue(bool(GetProgramiv(gl, mGLName, pname)));
default:
mContext->ErrorInvalidEnumInfo("getProgramParameter: `pname`",
pname);
return JS::NullValue();
}
}
void COMPLETION_PORT_IMPL::StartWaiter( COMPLETION_WAITER *waiter )
{
// remove a packet from the queue
COMPLETION_PACKET *packet = queue.Head();
assert( packet );
queue.Unlink( packet );
// pass the packet to the waiting thread
waiter->SetPacket( packet );
// unlink the waiter, and possibly unlink this port
waiter_list.Unlink( waiter );
if (waiter_list.Empty() && IsLinked())
waiting_thread_ports.Unlink( this );
// restart the waiter last
waiter->Start();
}
GLint
WebGLProgram::GetAttribLocation(const nsAString& userName_wide) const
{
if (!ValidateGLSLVariableName(userName_wide, mContext, "getAttribLocation"))
return -1;
if (!IsLinked()) {
mContext->ErrorInvalidOperation("getAttribLocation: `program` must be linked.");
return -1;
}
const NS_LossyConvertUTF16toASCII userName(userName_wide);
const webgl::AttribInfo* info;
if (!LinkInfo()->FindAttrib(userName, &info))
return -1;
return GLint(info->mLoc);
}
already_AddRefed<WebGLUniformLocation>
WebGLProgram::GetUniformLocation(const nsAString& userName_wide) const
{
if (!ValidateGLSLVariableName(userName_wide, mContext, "getUniformLocation"))
return nullptr;
if (!IsLinked()) {
mContext->ErrorInvalidOperation("getUniformLocation: `program` must be linked.");
return nullptr;
}
const NS_LossyConvertUTF16toASCII userName(userName_wide);
nsDependentCString baseUserName;
bool isArray;
size_t arrayIndex;
if (!ParseName(userName, &baseUserName, &isArray, &arrayIndex))
return nullptr;
const WebGLActiveInfo* activeInfo;
if (!LinkInfo()->FindUniform(baseUserName, &activeInfo))
return nullptr;
const nsCString& baseMappedName = activeInfo->mBaseMappedName;
nsAutoCString mappedName(baseMappedName);
if (isArray) {
mappedName.AppendLiteral("[");
mappedName.AppendInt(uint32_t(arrayIndex));
mappedName.AppendLiteral("]");
}
gl::GLContext* gl = mContext->GL();
gl->MakeCurrent();
GLint loc = gl->fGetUniformLocation(mGLName, mappedName.BeginReading());
if (loc == -1)
return nullptr;
RefPtr<WebGLUniformLocation> locObj = new WebGLUniformLocation(mContext, LinkInfo(),
loc, activeInfo);
return locObj.forget();
}
void
WebGLProgram::GetActiveUniformBlockName(GLuint uniformBlockIndex, nsAString& retval) const
{
if (!IsLinked()) {
mContext->ErrorInvalidOperation("getActiveUniformBlockName: `program` must be linked.");
return;
}
const webgl::LinkedProgramInfo* linkInfo = LinkInfo();
GLuint uniformBlockCount = (GLuint) linkInfo->uniformBlocks.size();
if (uniformBlockIndex >= uniformBlockCount) {
mContext->ErrorInvalidValue("getActiveUniformBlockName: index %u invalid.", uniformBlockIndex);
return;
}
const webgl::UniformBlockInfo* blockInfo = linkInfo->uniformBlocks[uniformBlockIndex];
retval.Assign(NS_ConvertASCIItoUTF16(blockInfo->mBaseUserName));
}
