mirror/projectm
3
0
Fork 0
mirror of https://github.com/projectM-visualizer/projectm.git synced 2026-03-01 21:16:01 +00:00
Code Issues Projects Releases Wiki Activity

partial preset factory integration

Browse Source 
git-svn-id: https://projectm.svn.sourceforge.net/svnroot/projectm/personal/carm/represet@1137 6778bc44-b910-0410-a7a0-be141de4315d
This commit is contained in:
w1z7ard
2008-09-07 16:35:30 +00:00
parent 051ad3d7b7
commit c83161e549
15 changed files with 303 additions and 313 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/libprojectM/CMakeLists.txt
View File

@ -1,4 +1,5 @@
PROJECT(projectM)
cmake_minimum_required(VERSION 2.6.0)
OPTION (USE_DEVIL "Use devIL for image loading rather than the builtin SOIL library" OFF)
@ -32,7 +33,7 @@ Func.cpp Eval.cpp PerFrameEqn.cpp PerPointEqn.cpp fftsg.cpp KeyHandler.cpp
timer.cpp wipemalloc.cpp BuiltinFuncs.cpp BuiltinParams.cpp Renderer.cpp
PresetLoader.cpp PresetChooser.cpp PresetFrameIO.cpp PresetMerge.cpp PipelineContext.cpp
ConfigFile.cpp IdlePreset.cpp TextureManager.cpp TimeKeeper.cpp Filters.cpp Renderable.cpp Pipeline.cpp PerPixelMesh.cpp
MilkdropWaveform.cpp Waveform.cpp VideoEcho.cpp Shader.cpp PerlinNoise.cpp UserTexture.cpp ShaderEngine.cpp ${GLEW_SOURCES})
MilkdropWaveform.cpp Waveform.cpp VideoEcho.cpp Shader.cpp PerlinNoise.cpp UserTexture.cpp ShaderEngine.cpp Common.cpp ${GLEW_SOURCES})
if (USE_DEVIL)
SET (projectM_SOURCES ${projectM_SOURCES})

17
src/libprojectM/Common.hpp
View File

@ -133,6 +133,23 @@ extern FILE *fmemopen(void *buf, size_t len, const char *pMode);
#else
#define PATH_SEPARATOR UNIX_PATH_SEPARATOR
#endif /** WIN32 */
#include <string>
const std::string PROJECTM_FILE_EXTENSION("prjm");
const std::string MILKDROP_FILE_EXTENSION("milk");
const std::string PROJECTM_MODULE_EXTENSION("so");
inline std::string parseExtension(const std::string & filename) {
std::size_t start = filename.find_last_of('.');
if (start == std::string::npos || start >= (filename.length()-1))
return "";
else
return filename.substr(start+1, filename.length());
}
inline void DWRITE( char *fmt, ... ) {
return;

75
src/libprojectM/Expr.cpp
View File

@ -43,9 +43,6 @@ float GenExpr::eval_gen_expr ( int mesh_i, int mesh_j )
case TREE_T:
return ( ( TreeExpr* ) ( item ) )->eval_tree_expr ( mesh_i, mesh_j );
default:
#ifdef EVAL_DEBUG
DWRITE ( "eval_gen_expr: general expression matched no cases!\n" );
#endif
return EVAL_ERROR;
}
@ -62,28 +59,16 @@ float PrefunExpr::eval_prefun_expr ( int mesh_i, int mesh_j )
assert(arg_list);
#ifdef EVAL_DEBUG_DOUBLE
DWRITE ( "fn[" );
#endif
//printf("numargs %d", num_args);
/* Evaluate each argument before calling the function itself */
for ( int i = 0; i < num_args; i++ )
{
arg_list[i] = expr_list[i]->eval_gen_expr ( mesh_i, mesh_j );
#ifdef EVAL_DEBUG_DOUBLE
if ( i < ( num_args - 1 ) )
DWRITE ( ", " );
#endif
//printf("numargs %x", arg_list[i]);
}
#ifdef EVAL_DEBUG_DOUBLE
DWRITE ( "]" );
#endif
/* Now we call the function, passing a list of
floats as its argument */
@ -102,9 +87,6 @@ float ValExpr::eval_val_expr ( int mesh_i, int mesh_j )
/* Value is a constant, return the float value */
if ( type == CONSTANT_TERM_T )
{
#ifdef EVAL_DEBUG
DWRITE ( "%.4f", term.constant );
#endif
return ( term.constant );
}
@ -115,16 +97,10 @@ float ValExpr::eval_val_expr ( int mesh_i, int mesh_j )
{
case P_TYPE_BOOL:
#ifdef EVAL_DEBUG
DWRITE ( "(%s:%.4f)", term.param->name.c_str(), ( float ) ( * ( ( bool* ) ( term.param->engine_val ) ) ) );
#endif
return ( float ) ( * ( ( bool* ) ( term.param->engine_val ) ) );
case P_TYPE_INT:
#ifdef EVAL_DEBUG
DWRITE ( "(%s:%.4f)", term.param->name.c_str(), ( float ) ( * ( ( int* ) ( term.param->engine_val ) ) ) );
#endif
return ( float ) ( * ( ( int* ) ( term.param->engine_val ) ) );
@ -179,54 +155,12 @@ float TreeExpr::eval_tree_expr ( int mesh_i, int mesh_j )
/* Otherwise, this node is an infix operator. Evaluate
accordingly */
#ifdef EVAL_DEBUG
DWRITE ( "(" );
#endif
assert(left);
left_arg = left->eval_tree_expr ( mesh_i, mesh_j );
#ifdef EVAL_DEBUG
switch ( infix_op->type )
{
case INFIX_ADD:
DWRITE ( "+" );
break;
case INFIX_MINUS:
DWRITE ( "-" );
break;
case INFIX_MULT:
DWRITE ( "*" );
break;
case INFIX_MOD:
DWRITE ( "%%" );
break;
case INFIX_OR:
DWRITE ( "|" );
break;
case INFIX_AND:
DWRITE ( "&" );
break;
case INFIX_DIV:
DWRITE ( "/" );
break;
default:
DWRITE ( "?" );
}
#endif
assert(right);
right_arg = right->eval_tree_expr ( mesh_i, mesh_j );
#ifdef EVAL_DEBUG
DWRITE ( ")" );
#endif
#ifdef EVAL_DEBUG
DWRITE ( "\n" );
#endif
switch ( infix_op->type )
{
@ -239,9 +173,6 @@ float TreeExpr::eval_tree_expr ( int mesh_i, int mesh_j )
case INFIX_MOD:
if ( ( int ) right_arg == 0 )
{
#ifdef EVAL_DEBUG
DWRITE ( "eval_tree_expr: modulo zero!\n" );
#endif
return PROJECTM_DIV_BY_ZERO;
}
return ( ( int ) left_arg % ( int ) right_arg );
@ -252,16 +183,10 @@ float TreeExpr::eval_tree_expr ( int mesh_i, int mesh_j )
case INFIX_DIV:
if ( right_arg == 0 )
{
#ifdef EVAL_DEBUG
DWRITE ( "eval_tree_expr: division by zero!\n" );
#endif
return MAX_DOUBLE_SIZE;
}
return ( left_arg / right_arg );
default:
#ifdef EVAL_DEBUG
DWRITE ( "eval_tree_expr: unknown infix operator!\n" );
#endif
return EVAL_ERROR;
}

7
src/libprojectM/IdlePreset.cpp
View File

@ -2,6 +2,7 @@
#include <sstream>
#include <string>
#if 0
const std::string IdlePreset::IDLE_PRESET_NAME
("Geiss & Sperl - Feedback (projectM idle HDR mix)");
@ -201,6 +202,10 @@ std::auto_ptr<Preset> IdlePreset::allocate( PresetInputs & presetInputs, PresetO
{
std::istringstream in(presetText());
return std::auto_ptr<Preset>(new Preset(in, IDLE_PRESET_NAME, presetInputs, presetOutputs));
return std::auto_ptr<Preset>(new Preset(in, IDLE_PRESET_NAME, p);
std::cerr << "fix me" << std::endl;
abort();
}
#endif

6
src/libprojectM/IdlePreset.hpp
View File

@ -6,14 +6,12 @@
/// A preset that does not depend on the file system to be loaded. This allows projectM to render
/// something (ie. self indulgent project advertisting) even when no valid preset directory is found.
class IdlePreset {
class IdlePresetFactory {
public:
/// Allocate a new idle preset instance
/// \param presetInputs the preset inputs instance to associate with the preset
/// \param presetOutputs the preset output instance to associate with the preset
/// \returns a newly allocated auto pointer of an idle preset instance
static std::auto_ptr<Preset> allocate(PresetInputs & presetInputs, PresetOutputs & presetOutputs);
std::auto_ptr<Preset> allocate();
private:
static std::string presetText();
static const std::string IDLE_PRESET_NAME;

6
src/libprojectM/KeyHandler.cpp
View File

@ -168,7 +168,7 @@ void projectM::default_key_handler( projectMEvent event, projectMKeycode keycode
case PROJECTM_K_n:
m_presetChooser->nextPreset(*m_presetPos);
presetSwitchedEvent(true, **m_presetPos);
m_activePreset = m_presetPos->allocate(this->presetInputs, this->presetOutputs);
m_activePreset = m_presetPos->allocate();
renderer->SetPipeline(presetOutputs);
renderer->setPresetName(m_activePreset->name());
timeKeeper->StartPreset();
@ -181,7 +181,7 @@ void projectM::default_key_handler( projectMEvent event, projectMKeycode keycode
*m_presetPos = m_presetChooser->weightedRandom();
presetSwitchedEvent(true, **m_presetPos);
m_activePreset = m_presetPos->allocate(this->presetInputs, this->presetOutputs);
m_activePreset = m_presetPos->allocate();
renderer->SetPipeline(presetOutputs);
assert(m_activePreset.get());
@ -208,7 +208,7 @@ void projectM::default_key_handler( projectMEvent event, projectMKeycode keycode
--(*m_presetPos);
}
m_activePreset = m_presetPos->allocate(this->presetInputs, this->presetOutputs);
m_activePreset = m_presetPos->allocate();
renderer->SetPipeline(presetOutputs);
renderer->setPresetName(m_activePreset->name());

2
src/libprojectM/Pipeline.cpp
View File

@ -44,6 +44,6 @@ if (staticPerPixel)
}
}
void Pipeline::Render(const BeatDetect &music, const PipelineContext &context){}
//void Pipeline::Render(const BeatDetect &music, const PipelineContext &context){}
Point Pipeline::PerPixel(Point p, const PerPixelContext context)
{return p;}

3
src/libprojectM/PipelineContext.hpp
View File

@ -12,11 +12,12 @@ class PipelineContext
{
public:
int fps;
float time;
float time;
int frame;
float progress;
PipelineContext();
virtual ~PipelineContext();
};
#endif /* PIPELINECONTEXT_HPP_ */

51
src/libprojectM/PresetChooser.hpp
View File

@ -43,14 +43,14 @@ public:
/// \param presetInputs the preset inputs to associate with the preset upon construction
/// \param presetOutputs the preset outputs to associate with the preset upon construction
/// \returns an autopointer of the newly allocated preset
std::auto_ptr<Preset> allocate( PresetInputs & presetInputs, PresetOutputs & presetOutputs);
std::auto_ptr<Preset> allocate();
/// Set the chooser asocciated with this iterator
void setChooser(const PresetChooser & chooser);
private:
std::size_t m_currentIndex;
const PresetChooser * m_presetChooser;
std::size_t _currentIndex;
const PresetChooser * _presetChooser;
};
@ -70,14 +70,12 @@ public:
/// \param presetInputs the preset inputs to associate with the preset upon construction
/// \param presetOutputs the preset outputs to associate with the preset upon construction
/// \returns an auto pointer of the newly allocated preset
std::auto_ptr<Preset> directoryIndex(std::size_t index, PresetInputs & presetInputs,
PresetOutputs & presetOutputs) const;
std::auto_ptr<Preset> directoryIndex(std::size_t index) const;
/// Gets the number of presets last believed to exist in the preset loader's filename collection
/// \returns the number of presets in the collection
std::size_t getNumPresets() const;
std::size_t size() const;
/// An STL-esque iterator to begin traversing presets from a directory
/// \param index the index to begin iterating at. Assumed valid between [0, num presets)
/// \returns the position of the first preset in the collection
@ -103,34 +101,34 @@ public:
private:
const PresetLoader * m_presetLoader;
const PresetLoader * _presetLoader;
};
inline PresetChooser::PresetChooser(const PresetLoader & presetLoader):m_presetLoader(&presetLoader) {}
inline PresetChooser::PresetChooser(const PresetLoader & presetLoader):_presetLoader(&presetLoader) {}
inline std::size_t PresetChooser::getNumPresets() const {
return m_presetLoader->getNumPresets();
inline std::size_t PresetChooser::size() const {
return _presetLoader->size();
}
inline void PresetIterator::setChooser(const PresetChooser & chooser) {
m_presetChooser = &chooser;
_presetChooser = &chooser;
}
inline std::size_t PresetIterator::operator*() const {
return m_currentIndex;
return _currentIndex;
}
inline PresetIterator::PresetIterator(std::size_t start):m_currentIndex(start) {}
inline PresetIterator::PresetIterator(std::size_t start):_currentIndex(start) {}
inline void PresetIterator::operator++() {
assert(m_currentIndex < m_presetChooser->getNumPresets());
m_currentIndex++;
assert(_currentIndex < _presetChooser->size());
_currentIndex++;
}
inline void PresetIterator::operator--() {
assert(m_currentIndex > 0);
m_currentIndex--;
assert(_currentIndex > 0);
_currentIndex--;
}
inline bool PresetIterator::operator !=(const PresetIterator & presetPos) const {
@ -142,8 +140,8 @@ inline bool PresetIterator::operator ==(const PresetIterator & presetPos) const
return (*presetPos == **this);
}
inline std::auto_ptr<Preset> PresetIterator::allocate( PresetInputs & presetInputs, PresetOutputs & presetOutputs) {
return m_presetChooser->directoryIndex(m_currentIndex, presetInputs, presetOutputs);
inline std::auto_ptr<Preset> PresetIterator::allocate() {
return _presetChooser->directoryIndex(_currentIndex);
}
inline void PresetChooser::nextPreset(PresetIterator & presetPos) {
@ -178,26 +176,25 @@ inline PresetIterator PresetChooser::begin(unsigned int index) const{
}
inline PresetIterator PresetChooser::end() const {
PresetIterator pos(m_presetLoader->getNumPresets());
PresetIterator pos(_presetLoader->size());
pos.setChooser(*this);
return pos;
}
inline bool PresetChooser::empty() const {
return m_presetLoader->getNumPresets() == 0;
return _presetLoader->size() == 0;
}
inline std::auto_ptr<Preset> PresetChooser::directoryIndex(std::size_t index, PresetInputs & presetInputs,
PresetOutputs & presetOutputs) const {
inline std::auto_ptr<Preset> PresetChooser::directoryIndex(std::size_t index) const {
return m_presetLoader->loadPreset(index, presetInputs, presetOutputs);
return _presetLoader->loadPreset(index);
}
inline PresetChooser::iterator PresetChooser::weightedRandom() const {
std::size_t index = RandomNumberGenerators::weightedRandom
(m_presetLoader->getPresetRatings(), m_presetLoader->getPresetRatingsSum());
(_presetLoader->getPresetRatings(), _presetLoader->getPresetRatingsSum());
return begin(index);
}

37
src/libprojectM/PresetFactory.hpp Normal file
View File

@ -0,0 +1,37 @@
//
// C++ Interface: PresetFactory
//
// Description:
//
//
// Author: Carmelo Piccione <carmelo.piccione@gmail.com>, (C) 2008
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include "Preset.hpp"
#include <memory>
#ifndef __PRESET_FACTORY_HPP
#define __PRESET_FACTORY_HPP
class PresetFactory {
public:
PresetFactory() {}
virtual ~PresetFactory() {}
/// Constructs a new preset given an url
/// \param url a locational identifier referencing the preset
/// \returns a valid preset object- otherwise
virtual std::auto_ptr<Preset> allocate(std::string url, std::string name);
};
#endif

353
src/libprojectM/PresetLoader.cpp
View File

@ -11,6 +11,7 @@
//
#include "PresetLoader.hpp"
#include "Preset.hpp"
#include "PresetFactory.hpp"
#include <iostream>
#include <sstream>
#include <set>
@ -34,122 +35,120 @@ extern "C"
#include "Common.hpp"
const std::string PresetLoader::PROJECTM_FILE_EXTENSION(".prjm");
const std::string PresetLoader::MILKDROP_FILE_EXTENSION(".milk");
PresetLoader::PresetLoader(std::string dirname = std::string()) :m_dirname(dirname), m_dir(0), m_ratingsSum(0)
PresetLoader::PresetLoader ( std::string dirname = std::string() ) :_dirname ( dirname ), _dir ( 0 ), _ratingsSum ( 0 )
{
// Do one scan
if (m_dirname != std::string())
rescan();
// Do one scan
if ( _dirname != std::string() )
rescan();
}
PresetLoader::~PresetLoader()
{
if (m_dir)
closedir(m_dir);
if ( _dir )
closedir ( _dir );
}
void PresetLoader::setScanDirectory(std::string dirname)
void PresetLoader::setScanDirectory ( std::string dirname )
{
m_dirname = dirname;
_dirname = dirname;
}
void PresetLoader::rescan()
{
// std::cerr << "Rescanning..." << std::endl;
// std::cerr << "Rescanning..." << std::endl;
// Clear the directory entry collection
m_entries.clear();
m_presetNames.clear();
m_ratings.clear();
m_ratingsSum = 0;
// If directory already opened, close it first
if (m_dir)
{
closedir(m_dir);
m_dir = 0;
}
// Clear the directory entry collection
_entries.clear();
_presetNames.clear();
_ratings.clear();
_ratingsSum = 0;
// If directory already opened, close it first
if ( _dir )
{
closedir ( _dir );
_dir = 0;
}
// Allocate a new a stream given the current directory name
if ((m_dir = opendir(m_dirname.c_str())) == NULL)
{
handleDirectoryError();
return; // no files loaded. m_entries is empty
}
// Allocate a new a stream given the current directory name
if ( ( _dir = opendir ( _dirname.c_str() ) ) == NULL )
{
handleDirectoryError();
return; // no files loaded. _entries is empty
}
struct dirent * dir_entry;
std::set<std::string> alphaSortedFileSet;
std::set<std::string> alphaSortedPresetNameSet;
while ((dir_entry = readdir(m_dir)) != NULL)
{
struct dirent * dir_entry;
std::set<std::string> alphaSortedFileSet;
std::set<std::string> alphaSortedPresetNameSet;
std::ostringstream out;
// Convert char * to friendly string
std::string filename(dir_entry->d_name);
while ( ( dir_entry = readdir ( _dir ) ) != NULL )
{
// Verify extension is projectm or milkdrop
if ((filename.rfind(PROJECTM_FILE_EXTENSION) != (filename.length() - PROJECTM_FILE_EXTENSION.length()))
&& (filename.rfind(MILKDROP_FILE_EXTENSION) != (filename.length() - MILKDROP_FILE_EXTENSION.length())))
continue;
std::ostringstream out;
// Convert char * to friendly string
std::string filename ( dir_entry->d_name );
if (filename.length() <= MILKDROP_FILE_EXTENSION.length())
continue;
// Verify extension is projectm or milkdrop
if ( ( filename.rfind ( PROJECTM_FILE_EXTENSION ) != ( filename.length() - PROJECTM_FILE_EXTENSION.length() ) )
&& ( filename.rfind ( MILKDROP_FILE_EXTENSION ) != ( filename.length() - MILKDROP_FILE_EXTENSION.length() ) ) )
continue;
if (filename.length() > 0 && filename[0] == '.')
continue;
if ( filename.length() <= MILKDROP_FILE_EXTENSION.length() )
continue;
// Create full path name
out << m_dirname << PATH_SEPARATOR << filename;
if ( filename.length() > 0 && filename[0] == '.' )
continue;
// Add to our directory entry collection
alphaSortedFileSet.insert(out.str());
alphaSortedPresetNameSet.insert(filename);
// Create full path name
out << _dirname << PATH_SEPARATOR << filename;
// the directory entry struct is freed elsewhere
}
// Add to our directory entry collection
alphaSortedFileSet.insert ( out.str() );
alphaSortedPresetNameSet.insert ( filename );
// Push all entries in order from the file set to the file entries member (which is an indexed vector)
for (std::set<std::string>::iterator pos = alphaSortedFileSet.begin();
pos != alphaSortedFileSet.end();++pos)
m_entries.push_back(*pos);
// the directory entry struct is freed elsewhere
}
// Push all entries in order from the file set to the file entries member (which is an indexed vector)
for ( std::set<std::string>::iterator pos = alphaSortedFileSet.begin();
pos != alphaSortedFileSet.end();++pos )
_entries.push_back ( *pos );
// Push all preset names in similar fashion
for ( std::set<std::string>::iterator pos = alphaSortedPresetNameSet.begin();
pos != alphaSortedPresetNameSet.end();++pos )
_presetNames.push_back ( *pos );
// Give all presets equal rating of 3 - why 3? I don't know
_ratings = std::vector<int> ( _presetNames.size(), 3 );
_ratingsSum = 3 * _ratings.size();
assert ( _entries.size() == _presetNames.size() );
assert ( _ratings.size() == _entries.size() );
// Push all preset names in similar fashion
for (std::set<std::string>::iterator pos = alphaSortedPresetNameSet.begin();
pos != alphaSortedPresetNameSet.end();++pos)
m_presetNames.push_back(*pos);
// Give all presets equal rating of 3 - why 3? I don't know
m_ratings = std::vector<int>(m_presetNames.size(), 3);
m_ratingsSum = 3 * m_ratings.size();
assert(m_entries.size() == m_presetNames.size());
assert(m_ratings.size() == m_entries.size());
}
/// Associates a preset loading handler a file extension.
/// Any subsequent call to an extension overrides the previously set handler.
/// \param extension the file extension to attach the handler to
/// \param handler a preset loading handler that will be associated with the extension
void PresetLoader::registerHandler(const std::string & extension, PresetLoadingHandler * handler) {
void PresetLoader::registerFactory ( const std::string & extension, PresetFactory * factory ) {
_factories[extension] = factory;
}
_handlers[extension'] = handler;
// }
std::auto_ptr<Preset> PresetLoader::loadPreset(unsigned int index, PresetInputs & presetInputs, PresetOutputs & presetOutputs) const
std::auto_ptr<Preset> PresetLoader::loadPreset ( unsigned int index ) const
{
// Check that index isn't insane
assert(index >= 0);
assert(index < m_entries.size());
// Check that index isn't insane
assert ( index >= 0 );
assert ( index < _entries.size() );
// Return a new autopointer to a preset
return std::auto_ptr<Preset>(new Preset(m_entries[index], m_presetNames[index], presetInputs, presetOutputs));
// Return a new autopointer to a preset
const std::string extension = parseExtension ( _entries[index] );
if ( !_factories.count ( extension ) )
return std::auto_ptr<Preset> ( 0 );
else
return _factories[extension]->allocate ( _entries[index], _presetNames[index] );
}
void PresetLoader::handleDirectoryError()
@ -159,99 +158,107 @@ void PresetLoader::handleDirectoryError()
std::cerr << "[PresetLoader] warning: errno unsupported on win32 platforms. fix me" << std::endl;
#else
switch (errno)
{
case ENOENT:
std::cerr << "[PresetLoader] ENOENT error. The path \"" << this->m_dirname << "\" probably does not exist. \"man open\" for more info." << std::endl;
break;
case ENOMEM:
std::cerr << "[PresetLoader] out of memory! Are you running Windows?" << std::endl;
abort();
case ENOTDIR:
std::cerr << "[PresetLoader] directory specified is not a preset directory! Trying to continue..." << std::endl;
break;
case ENFILE:
std::cerr << "[PresetLoader] Your system has reached its open file limit. Trying to continue..." << std::endl;
break;
case EMFILE:
std::cerr << "[PresetLoader] too many files in use by projectM! Bailing!" << std::endl;
break;
case EACCES:
std::cerr << "[PresetLoader] permissions issue reading the specified preset directory." << std::endl;
break;
default:
break;
}
switch ( errno )
{
case ENOENT:
std::cerr << "[PresetLoader] ENOENT error. The path \"" << this->_dirname << "\" probably does not exist. \"man open\" for more info." << std::endl;
break;
case ENOMEM:
std::cerr << "[PresetLoader] out of memory! Are you running Windows?" << std::endl;
abort();
case ENOTDIR:
std::cerr << "[PresetLoader] directory specified is not a preset directory! Trying to continue..." << std::endl;
break;
case ENFILE:
std::cerr << "[PresetLoader] Your system has reached its open file limit. Trying to continue..." << std::endl;
break;
case EMFILE:
std::cerr << "[PresetLoader] too many files in use by projectM! Bailing!" << std::endl;
break;
case EACCES:
std::cerr << "[PresetLoader] permissions issue reading the specified preset directory." << std::endl;
break;
default:
break;
}
#endif
}
void PresetLoader::setRating(unsigned int index, int rating) {
assert(index >=0);
assert(index < m_ratings.size());
m_ratingsSum -= m_ratings[index];
m_ratings[index] = rating;
m_ratingsSum += rating;
assert(m_entries.size() == m_presetNames.size());
assert(m_ratings.size() == m_entries.size());
}
unsigned int PresetLoader::addPresetURL(const std::string & url, const std::string & presetName, int rating) {
m_entries.push_back(url);
m_presetNames.push_back(presetName);
m_ratings.push_back(rating);
m_ratingsSum += rating;
assert(m_entries.size() == m_presetNames.size());
assert(m_ratings.size() == m_entries.size());
return m_entries.size()-1;
}
void PresetLoader::removePreset(unsigned int index) {
m_entries.erase(m_entries.begin()+index);
m_presetNames.erase(m_presetNames.begin()+index);
m_ratingsSum -= m_ratings[index];
m_ratings.erase(m_ratings.begin()+index);
assert(m_entries.size() == m_presetNames.size());
assert(m_ratings.size() == m_entries.size());
}
const std::string & PresetLoader::getPresetURL ( unsigned int index) const {
return m_entries[index];
}
const std::string & PresetLoader::getPresetName ( unsigned int index) const {
return m_presetNames[index];
}
int PresetLoader::getPresetRating ( unsigned int index) const {
return m_ratings[index];
}
const std::vector<int> & PresetLoader::getPresetRatings () const {
return m_ratings;
}
int PresetLoader::getPresetRatingsSum () const {
return m_ratingsSum;
}
void PresetLoader::insertPresetURL(unsigned int index, const std::string & url, const std::string & presetName, int rating)
void PresetLoader::setRating ( unsigned int index, int rating )
{
m_entries.insert(m_entries.begin()+index, url);
m_presetNames.insert(m_presetNames.begin() + index, presetName);
m_ratings.insert(m_ratings.begin()+index, rating);
m_ratingsSum += rating;
assert(m_entries.size() == m_presetNames.size());
assert(m_ratings.size() == m_entries.size());
assert ( index >=0 );
assert ( index < _ratings.size() );
_ratingsSum -= _ratings[index];
_ratings[index] = rating;
_ratingsSum += rating;
assert ( _entries.size() == _presetNames.size() );
assert ( _ratings.size() == _entries.size() );
}
unsigned int PresetLoader::addPresetURL ( const std::string & url, const std::string & presetName, int rating )
{
_entries.push_back ( url );
_presetNames.push_back ( presetName );
_ratings.push_back ( rating );
_ratingsSum += rating;
assert ( _entries.size() == _presetNames.size() );
assert ( _ratings.size() == _entries.size() );
return _entries.size()-1;
}
void PresetLoader::removePreset ( unsigned int index )
{
_entries.erase ( _entries.begin() +index );
_presetNames.erase ( _presetNames.begin() +index );
_ratingsSum -= _ratings[index];
_ratings.erase ( _ratings.begin() +index );
assert ( _entries.size() == _presetNames.size() );
assert ( _ratings.size() == _entries.size() );
}
const std::string & PresetLoader::getPresetURL ( unsigned int index ) const
{
return _entries[index];
}
const std::string & PresetLoader::getPresetName ( unsigned int index ) const
{
return _presetNames[index];
}
int PresetLoader::getPresetRating ( unsigned int index ) const
{
return _ratings[index];
}
const std::vector<int> & PresetLoader::getPresetRatings () const
{
return _ratings;
}
int PresetLoader::getPresetRatingsSum () const
{
return _ratingsSum;
}
void PresetLoader::insertPresetURL ( unsigned int index, const std::string & url, const std::string & presetName, int rating )
{
_entries.insert ( _entries.begin() +index, url );
_presetNames.insert ( _presetNames.begin() + index, presetName );
_ratings.insert ( _ratings.begin() +index, rating );
_ratingsSum += rating;
assert ( _entries.size() == _presetNames.size() );
assert ( _ratings.size() == _entries.size() );
}

40
src/libprojectM/PresetLoader.hpp
View File

@ -18,31 +18,29 @@
#endif
#include <vector>
#include <map>
class Preset;
class PresetInputs;
class PresetOutputs;
class PresetFactory;
class PresetLoader {
public:
static const std::string PROJECTM_FILE_EXTENSION;
static const std::string MILKDROP_FILE_EXTENSION;
/// Initializes the preset loader with the target directory specified
PresetLoader(std::string dirname);
~PresetLoader();
/// Load a preset by specifying a filename of the directory (that is, NOT full path)
std::auto_ptr<Preset> loadPreset(unsigned int index, PresetInputs & presetInputs,
PresetOutputs & presetOutputs) const;
std::auto_ptr<Preset> loadPreset(unsigned int index) const;
/// Associates a preset loading handler a file extension.
/// Any subsequent call to an extension overrides the previously set handler.
/// Associates a preset factory to a file extension.
/// Any subsequent registrations of an extension overrides the previously set one
/// \param extension the file extension to attach the handler to
/// \param handler a preset loading handler that will be associated with the extension
void registerHandler(const std::string & extension, PresetLoadingHandler * handler);
void registerFactory(const std::string & extension, PresetFactory * factory);
/// Add a preset to the loader's collection.
/// \param url an url referencing the preset
@ -60,7 +58,7 @@ class PresetLoader {
void insertPresetURL (unsigned int index, const std::string & url, const std::string & presetName, int rating);
/// Clears all presets from the collection
inline void clear() { m_entries.clear(); m_presetNames.clear(); m_ratings.clear(); m_ratingsSum = 0; }
inline void clear() { _entries.clear(); _presetNames.clear(); _ratings.clear(); _ratingsSum = 0; }
const std::vector<int> & getPresetRatings() const;
int getPresetRatingsSum() const;
@ -70,7 +68,7 @@ class PresetLoader {
void setRating(unsigned int index, int rating);
/// Get a preset rating given an index
int getPresetRating ( unsigned int index) const;
int getPresetRating ( unsigned int index) const;
/// Get a preset url given an index
const std::string & getPresetURL ( unsigned int index) const;
@ -79,8 +77,8 @@ class PresetLoader {
const std::string & getPresetName ( unsigned int index) const;
/** Returns the number of presets in the active directory */
inline std::size_t getNumPresets() const {
return m_entries.size();
inline std::size_t size() const {
return _entries.size();
}
/** Sets the directory where the loader will search for files */
@ -88,7 +86,7 @@ class PresetLoader {
/// Returns the directory path associated with this preset chooser
inline const std::string & directoryName() const {
return m_dirname;
return _dirname;
}
/** Rescans the active preset directory */
@ -96,15 +94,15 @@ class PresetLoader {
private:
void handleDirectoryError();
std::string m_dirname;
DIR * m_dir;
std::map<std::string, PresetLoadingHandler> _handlers;
int m_ratingsSum;
std::string _dirname;
DIR * _dir;
mutable std::map<std::string, PresetFactory*> _factories;
int _ratingsSum;
// vector chosen for speed, but not great for reverse index lookups
std::vector<std::string> m_entries;
std::vector<std::string> m_presetNames;
std::vector<int> m_ratings;
std::vector<std::string> _entries;
std::vector<std::string> _presetNames;
std::vector<int> _ratings;
};

1
src/libprojectM/PresetMerge.hpp
View File

@ -2,6 +2,7 @@
#define PRESET_MERGE_HPP
#include "Preset.hpp"
#include "Pipeline.hpp"
#include "PresetFrameIO.hpp"
class PresetMerger
{

2
src/libprojectM/Renderer.cpp
View File

@ -411,7 +411,9 @@ void Renderer::reset(int w, int h)
this -> vw = w;
this -> vh = h;
#if USE_CG
shaderEngine.setAspect(aspect);
#endif
glShadeModel(GL_SMOOTH);

13
src/libprojectM/projectM.cpp
View File

@ -736,8 +736,9 @@ int projectM::initPresetTools()
*m_presetPos = m_presetChooser->end();
// Load idle preset
//std::cerr << "[projectM] Allocating idle preset..." << std::endl;
m_activePreset = IdlePreset::allocate ( presetInputs, presetOutputs );
std::cerr << "[projectM] Allocating idle preset..." << std::endl;
abort();
//m_activePreset = IdlePreset::allocate ( presetInputs, presetOutputs );
// Case where no valid presets exist in directory. Could also mean
// playlist initialization was deferred
@ -832,12 +833,12 @@ void projectM::selectPreset ( unsigned int index )
if ( m_presetChooser->empty() )
return;
assert ( index < m_presetLoader->getNumPresets() );
assert ( index < m_presetLoader->size());
assert ( index >= 0 );
*m_presetPos = m_presetChooser->begin ( index );
m_activePreset = m_presetPos->allocate ( presetInputs, presetOutputs );
m_activePreset = m_presetPos->allocate ();
renderer->setPresetName ( m_activePreset->name() );
@ -851,7 +852,7 @@ void projectM::switchPreset(std::auto_ptr<Preset> & targetPreset, PresetInputs &
else
m_presetChooser->nextPreset(*m_presetPos);
targetPreset = m_presetPos->allocate( inputs, outputs );
targetPreset = m_presetPos->allocate();
// Set preset name here- event is not done because at the moment this function is oblivious to smooth/hard switches
renderer->setPresetName ( targetPreset->name() );
@ -914,7 +915,7 @@ bool projectM::presetPositionValid() const {
unsigned int projectM::getPlaylistSize() const
{
return m_presetLoader->getNumPresets();
return m_presetLoader->size();
}
void projectM:: changePresetRating (unsigned int index, int rating) {