bool Shader::loadFromFile(const Shader::Type type, const std::string& filename)
{
if(p_shader_id != 0)
{
glDeleteShader(p_shader_id);
}
std::string shader_source;
if(!loadShaderSource(filename, shader_source))
{
return false;
}
loadFromSource(type, shader_source);
return true;
}
//-----------------------------------------------------------------------------
void D3D11GpuProgram::loadImpl(void)
{
// Normal load-from-source approach
if (mLoadFromFile)
{
// find & load source code
DataStreamPtr stream =
ResourceGroupManager::getSingleton().openResource(
mFilename, mGroup, true, this);
mSource = stream->getAsString();
}
// Call polymorphic load
loadFromSource();
}
//---------------------------------------------------------------------------
void HighLevelGpuProgram::loadHighLevelImpl(void)
{
if (mLoadFromFile)
{
// find & load source code
DataStreamPtr stream =
ResourceGroupManager::getSingleton().openResource(
mFilename, mGroup, true, this);
mSource = stream->getAsString();
}
loadFromSource();
}
void QQuickLoader::setSource(const QUrl &url, bool needsClear)
{
Q_D(QQuickLoader);
if (d->source == url)
return;
if (needsClear)
d->clear();
d->source = url;
d->loadingFromSource = true;
if (d->active)
loadFromSource();
else
emit sourceChanged();
}
//-----------------------------------------------------------------------------
void GpuProgram::loadImpl(void)
{
if (mLoadFromFile)
{
// find & load source code
DataStreamPtr stream =
ResourceGroupManager::getSingleton().openResource(
mFilename, mGroup, true, this);
mSource = stream->getAsString();
}
// Call polymorphic load
try
{
loadFromSource();
if (!mDefaultParams.isNull())
{
// Keep a reference to old ones to copy
GpuProgramParametersSharedPtr savedParams = mDefaultParams;
// reset params to stop them being referenced in the next create
mDefaultParams.setNull();
// Create new params
mDefaultParams = createParameters();
// Copy old (matching) values across
// Don't use copyConstantsFrom since program may be different
mDefaultParams->copyMatchingNamedConstantsFrom(*savedParams.get());
}
}
catch (const Exception&)
{
StringStream ss;
ss << "Gpu program " << mName << " encountered an error "
<< "during loading and is thus not supported.";
mCompileErrorMessage = ss.str();
// will already have been logged
LogManager::getSingleton().stream() << mCompileErrorMessage;
mCompileError = true;
}
}
void QQuickLoader::setActive(bool newVal)
{
Q_D(QQuickLoader);
if (d->active == newVal)
return;
d->active = newVal;
if (newVal == true) {
if (d->loadingFromSource) {
loadFromSource();
} else {
loadFromSourceComponent();
}
} else {
// cancel any current incubation
if (d->incubator) {
d->incubator->clear();
delete d->itemContext;
d->itemContext = 0;
}
if (d->item) {
QQuickItemPrivate *p = QQuickItemPrivate::get(d->item);
p->removeItemChangeListener(d, watchedChanges);
// We can't delete immediately because our item may have triggered
// the Loader to load a different item.
d->item->setParentItem(0);
d->item->setVisible(false);
d->item = 0;
}
if (d->object) {
d->object->deleteLater();
d->object = 0;
emit itemChanged();
}
emit statusChanged();
}
emit activeChanged();
}
void OpenCLProgram::loadFromFile(std::string filename, bool isBinary) {
ofLog(OF_LOG_VERBOSE, "OpenCLProgram::loadFromFile " + filename + ", isBinary: " + ofToString(isBinary));
string fullPath = ofToDataPath(filename.c_str());
if(isBinary) {
// clCreateProgramWithBinary
ofLog(OF_LOG_ERROR, "Binary programs not implemented yet\n");
assert(false);
} else {
char *source = OpenCL_textFileRead((char*)fullPath.c_str());
if(source == NULL) {
ofLog(OF_LOG_ERROR, "Error loading program file: " + fullPath);
assert(false);
}
loadFromSource(source);
free(source);
}
}
void doLoadFromSource(void)
{
loadFromSource();
};
