void eDeferredRenderer::_loadShaders()
{
m_psRefraction = eShaderManager::loadPixelShader(ePS(refraction));
m_psNoLight = eShaderManager::loadPixelShader(ePS(nolight));
m_psForwLight = eShaderManager::loadPixelShader(ePS(forward_light));
m_psDefAmbient = eShaderManager::loadPixelShader(ePS(deferred_ambient));
m_psDefEnv = eShaderManager::loadPixelShader(ePS(deferred_env));
m_psDefGeo = eShaderManager::loadPixelShader(ePS(deferred_geo));
m_psDefLight = eShaderManager::loadPixelShader(ePS(deferred_light));
m_psDistance = eShaderManager::loadPixelShader(ePS(distance));
m_psShadow = eShaderManager::loadPixelShader(ePS(shadow));
m_psQuad = eShaderManager::loadPixelShader(ePS(quad));
m_psParticles = eShaderManager::loadPixelShader(ePS(particles));
m_vsNoLight = eShaderManager::loadVertexShader(eVS(nolight));
m_vsInstGeo = eShaderManager::loadVertexShader(eVS(instanced_geo));
m_vsDistance = eShaderManager::loadVertexShader(eVS(distance));
m_vsShadow = eShaderManager::loadVertexShader(eVS(shadow));
m_vsQuad = eShaderManager::loadVertexShader(eVS(quad));
m_vsParticles = eShaderManager::loadVertexShader(eVS(particles));
}
void omxLISRELExpectation::studyExoPred() // compare with similar function for RAM
{
if (data->defVars.size() == 0 || !TY || !TY->isSimple() || !PS->isSimple()) return;
Eigen::VectorXd estSave;
copyParamToModelFake1(currentState, estSave);
omxRecompute(PS, 0);
omxRecompute(LY, 0);
omxRecompute(BE, 0);
EigenMatrixAdaptor ePS(PS); // latent covariance
EigenMatrixAdaptor eLY(LY); // to manifest loading
EigenMatrixAdaptor eBE(BE); // to latent loading
Eigen::VectorXd hasVariance = ePS.diagonal().array().abs().matrix();
int found = 0;
std::vector<int> exoDataCol(PS->rows, -1);
int alNum = ~AL->matrixNumber;
for (int k=0; k < int(data->defVars.size()); ++k) {
omxDefinitionVar &dv = data->defVars[k];
if (dv.matrix == alNum && hasVariance[ dv.row ] == 0.0) {
for (int cx=0; cx < eBE.rows(); ++cx) {
if (eBE(cx, dv.row) == 0.0) continue;
mxThrow("%s: latent exogenous variables are not supported (%s -> %s)", name,
PS->rownames[dv.row], BE->rownames[cx]);
}
if (eLY.col(dv.row).array().abs().sum() == 0.) continue;
exoDataCol[dv.row] = dv.column;
found += 1;
dv.loadData(currentState, 0.);
if (verbose >= 1) {
mxLog("%s: set defvar '%s' for latent '%s' to exogenous mode",
name, data->columnName(dv.column), PS->rownames[dv.row]);
}
data->defVars.erase(data->defVars.begin() + k--);
}
}
copyParamToModelRestore(currentState, estSave);
if (!found) return;
slope = omxInitMatrix(LY->rows, found, currentState);
EigenMatrixAdaptor eSl(slope);
eSl.setZero();
for (int cx=0, ex=0; cx < PS->rows; ++cx) {
if (exoDataCol[cx] == -1) continue;
exoDataColumns.push_back(exoDataCol[cx]);
for (int rx=0; rx < LY->rows; ++rx) {
slope->addPopulate(LY, rx, cx, rx, ex);
}
ex += 1;
}
exoPredMean.resize(exoDataColumns.size());
for (int cx=0; cx < int(exoDataColumns.size()); ++cx) {
auto &e1 = data->rawCols[ exoDataColumns[cx] ];
Eigen::Map< Eigen::VectorXd > vec(e1.ptr.realData, data->numRawRows());
exoPredMean[cx] = vec.mean();
}
}
