コード例 #1
0
ファイル: Source.cpp プロジェクト: PADrend/Sound
//! [static] factory
Source * Source::create() {
	checkErrorStatus(__FILE__, __LINE__);
	uint32_t sourceId;
	alGenSources( 1, &sourceId );
	if(!checkErrorStatus(__FILE__, __LINE__, "Could not create Source.") || sourceId==0 ){
		return nullptr;
	}
	return new Source(sourceId);
}
コード例 #2
0
ファイル: Source.cpp プロジェクト: PADrend/Sound
void Source::dequeueBuffers(int num){
	checkErrorStatus(__FILE__, __LINE__);
	auto removedBuffers=new ALuint[num];
	alSourceUnqueueBuffers(sourceId,num,removedBuffers);
	delete []removedBuffers;
	if(checkErrorStatus(__FILE__, __LINE__, "Source::dequeueBuffers")){ // successful?
		buffers.erase(buffers.begin(),buffers.begin()+num);
	}
}
コード例 #3
0
ファイル: Sound.cpp プロジェクト: PADrend/Sound
//! [static]
bool initSoundSystem(){
	if(myContext != nullptr) { // already initialized?
		return true;
	}

	// Open the default device
	myDevice = alcOpenDevice(nullptr);
	checkALCErrorStatus(__FILE__, __LINE__, myDevice);
	if(myDevice == nullptr) {
		return false;
	}

	// Create Context
	myContext = alcCreateContext(myDevice, nullptr);
	checkALCErrorStatus(__FILE__, __LINE__, myDevice);
	if(myContext == nullptr) {
		return false;
	}

	alcMakeContextCurrent(myContext);
	checkALCErrorStatus(__FILE__, __LINE__, myDevice);

	if(!checkErrorStatus(__FILE__, __LINE__, "initSoundSystem()")){
		shutDownSoundSystem();
		return false;
	}
	return true;
}
コード例 #4
0
ファイル: Sound.cpp プロジェクト: PADrend/Sound
//! [static] factory
Buffer * createSilence(unsigned int freq,unsigned int size) {
	Util::Reference<Buffer> b(Buffer::create());
	if(b.isNull())
		return nullptr;

	const std::vector<uint8_t> data(size, 128);
	b->setData(AL_FORMAT_MONO8, data.data(), data.size(), freq);

	return checkErrorStatus(__FILE__, __LINE__) ? b.detachAndDecrease() : nullptr;
}
コード例 #5
0
int ShaderManager::compileShaders(GLuint type, std::string &directory)
{
  //Open the file
  std::ifstream file;
  file.open(directory.c_str(), std::ios::in);
  if(!file)
  {
    std::cout << directory + " could not be opened, no shaders loaded!" << std::endl;
    return -1;
  }

  std::string filename;
  GLuint shaderObject;
  GLchar *source;
  int len;
  //Opened, now read in the type and file name
  while(file.good())
  {
    //Load files into memory
    file >> filename;
    directory = project_mode_string + "Shaders\\" + filename;
    std::cout << "--------------------------------------------" << std::endl;
    std::cout << filename << ":" << std::endl;
    int err = loadFile(type, directory.c_str(), &source, &len);
    if(err)
      continue;

    //create shader objects
    shaderObject = glCreateShader(type); //Could be a vertex or fragment shader, it uses the TYPE
    //CONST STUFF so annoying
    const char *csource = source;
    const GLchar **p_source = &csource;
    glShaderSource(shaderObject, 1, p_source, &len);

    //Compile shader file
    glCompileShader(shaderObject);
    //Check if it compiled correctly
    err = checkErrorStatus(shaderObject, GL_COMPILE_STATUS);
    if(err)
      continue;
    std::cout << "Shader of type " << type << " compiled correctly: " << filename << std::endl;

    //Add it to the vector
    if(type == GL_VERTEX_SHADER)
      compiled_vertex_shaders.push_back(shaderObject);
    else
      compiled_fragment_shaders.push_back(shaderObject);
  }
  std::cout << "--------------------------------------------" << std::endl;
  file.close();
  return 0;
}
コード例 #6
0
ファイル: Sound.cpp プロジェクト: PADrend/Sound
//! [static] factory
Buffer * createNoise(unsigned int freq, unsigned int size) {
	Util::Reference<Buffer> b(Buffer::create());
	if(b.isNull())
		return nullptr;

	std::vector<uint8_t> noise;
	noise.reserve(size);
	unsigned int j = 1;
	for (unsigned int i = 0; i < size; ++i) {
		j = (j * 1234393 + i) % 0xffffff;
		noise.push_back(static_cast<uint8_t>(j) % 256);
	}
	b->setData(AL_FORMAT_MONO8, noise.data(), noise.size(),freq);

	return checkErrorStatus(__FILE__, __LINE__) ? b.detachAndDecrease() : nullptr;
}
コード例 #7
0
int ShaderManager::createPrograms()
{
  std::string directory = project_mode_string + "programs.txt";
  std::ifstream file;
  file.open(directory.c_str(), std::ios::in);
  if(!file)
  {
    std::cout << directory + " could not be opened, no shaders created!" << std::endl;
    return -1;
  }

  std::string prog_name;
  int v_shader, f_shader;
  while(file.good()  && !file.eof())
  {
    file >> prog_name;
    file >> v_shader;
    file >> f_shader;

    if(v_shader >= (int)(compiled_vertex_shaders.size()) || f_shader >= ((int)compiled_fragment_shaders.size()))
    {
      std::cout << "Could not link a program with values " << v_shader << ", " << f_shader << std::endl;
      continue;
    }
    GLuint program = glCreateProgram();
    glAttachShader(program, compiled_vertex_shaders[v_shader]);
    glAttachShader(program, compiled_fragment_shaders[f_shader]);
    glLinkProgram(program);
    
    int err = checkErrorStatus(program, GL_LINK_STATUS);
    if(err)
      continue;
    std::cout << prog_name << " - " << v_shader << ", " << f_shader << " linked correctly" << std::endl;
    shader_programs[prog_name] = program;
  }
  for(unsigned i = 0; i < compiled_vertex_shaders.size(); i++)
  {
    glDeleteShader(compiled_vertex_shaders[i]);
  }
  for(unsigned i = 0; i < compiled_fragment_shaders.size(); i++)
  {
    glDeleteShader(compiled_fragment_shaders[i]);
  }
  compiled_vertex_shaders.clear();
  compiled_fragment_shaders.clear();
  return 0;
}
コード例 #8
0
ファイル: Sound.cpp プロジェクト: PADrend/Sound
//! [static] factory
Buffer * createRectangleSound(unsigned int width, unsigned int freq, unsigned int size) {
	Util::Reference<Buffer> b(Buffer::create());
	if(b.isNull())
		return nullptr;

	std::vector<uint8_t> noise;
	noise.reserve(size);
	uint8_t value = 0;
	for (unsigned int i = 0; i < size; ++i) {
		if(i % width == 0) {
			value = 255 - value;
		}
		noise.push_back(value);
	}
	b->setData(AL_FORMAT_MONO8, noise.data(), noise.size(), freq);

	return checkErrorStatus(__FILE__, __LINE__) ? b.detachAndDecrease() : nullptr;
}
コード例 #9
0
ファイル: Sound.cpp プロジェクト: PADrend/Sound
//! [static] factory
Buffer * loadWAV(const std::string & filename) {
	Util::Reference<Buffer> b(Buffer::create());
	if(b.isNull())
		return nullptr;

	SDL_AudioSpec wav_spec;
	Uint32 wav_length;
	Uint8 *wav_buffer;

	if ( SDL_LoadWAV(filename.c_str(), &wav_spec, &wav_buffer, &wav_length) == nullptr ) {
		WARN("Could not open : "+ filename+ std::string( SDL_GetError()) );
		return nullptr;
	}

	unsigned int format=0;
	unsigned int freq = static_cast<unsigned int>(wav_spec.freq);
	if (wav_spec.format == AUDIO_U8 ) {
		if (wav_spec.channels==1)
			format=AL_FORMAT_MONO8;
		else
			format=AL_FORMAT_STEREO8;
	} else if (wav_spec.format == AUDIO_S16SYS ) {
		if (wav_spec.channels==1)
			format=AL_FORMAT_MONO16;
		else
			format=AL_FORMAT_STEREO16;
	}
	if (format==0) {
		WARN("Uninplemented WAV-format. Please add conversion routine ;).");
		return nullptr;
	} else
		b->setData(format,wav_buffer,wav_length,freq);

//    b->setData(AL_FORMAT_MONO8,noise,size,freq);
	SDL_FreeWAV(wav_buffer);

	return checkErrorStatus(__FILE__, __LINE__) ? b.detachAndDecrease() : nullptr;
}