C++ checkErrors函数代码示例

GLuint GLHelper::generateVAO(const GLuint number) {
    GLuint bufferID;
    glGenVertexArrays(number, &bufferID);
    vertexArrays.push_back(bufferID);
    checkErrors("generateVAO");
    return bufferID;
}

JNIEXPORT jlong JNICALL Java_org_librealsense_Native_rs2CreateConfig
  (JNIEnv *env, jclass) {
    rs2_error *error = NULL;
    rs2_config* config = rs2_create_config(&error);
    checkErrors(env, error);
    return (jlong) config;
}

JNIEXPORT void JNICALL Java_org_librealsense_Native_rs2PipelineStop
  (JNIEnv *env, jclass, jlong pipeAddr) {
    rs2_error *error = NULL;
    rs2_pipeline* pipe = (rs2_pipeline*)pipeAddr;
    rs2_pipeline_stop(pipe, &error);
    checkErrors(env, error);
}

 JNIEXPORT jlong JNICALL Java_org_librealsense_Native_rs2GetFrameStreamProfile
   (JNIEnv *env, jclass, jlong frameAddr) {
   rs2_error *error = NULL;
     rs2_frame* frame = (rs2_frame*) frameAddr;
     const rs2_stream_profile* streamProfile = rs2_get_frame_stream_profile(frame, &error);
     checkErrors(env, error);
     return (jlong)streamProfile;
 }

void ExprShortEdit::setExpressionString(const std::string& expression) {
    edit->setText(QString(expression.c_str()));
    controlRebuildTimer->setSingleShot(true);
    controlRebuildTimer->start(0);
    checkErrors();
    emit exprChanged();
}

GLuint GLHelper::createProgram(const std::vector<GLuint> &shaderList) {
    GLuint program = glCreateProgram();

    for (size_t iLoop = 0; iLoop < shaderList.size(); iLoop++) {
        glAttachShader(program, shaderList[iLoop]);
    }

    glLinkProgram(program);

    GLint status;
    glGetProgramiv(program, GL_LINK_STATUS, &status);

    if (status == GL_FALSE) {
        GLint infoLogLength;
        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);

        GLchar *strInfoLog = new GLchar[infoLogLength + 1];
        glGetProgramInfoLog(program, infoLogLength, NULL, strInfoLog);
        std::cerr << "Linking failed: \n" << strInfoLog << std::endl;
        delete[] strInfoLog;
    } else {
        std::cout << "Program compiled successfully" << std::endl;
    }

    for (size_t iLoop = 0; iLoop < shaderList.size(); iLoop++) {
        glDetachShader(program, shaderList[iLoop]);
    }

    checkErrors("createProgram");
    return program;
}

bool KSoundManager::playSong(std::string name, float volume, float stereo, bool loop)
{
	if(mSilent) return true;
	//printf("play %s, with looping = %i\n", name.c_str(), (int) loop); 
	
	//stop any current song
	if(song)
		stopSong();
	// don't even bother if no sound file specified
	if ("" == name || "data/music/ " == name)
		return false;
				
		result = mSystem->createSound(name.c_str(), FMOD_CREATESTREAM | FMOD_SOFTWARE | FMOD_2D, 0, &song); 

	if (!song)
	{
		printf("FMOD Error loading %s!\n", name.c_str());
		checkErrors();
		return false;
	}
	//extract the important part out of the name
	int startPos = (int)name.find_last_of("/");
	mCurrentSongName = name.substr(startPos + 1, name.size() - 4 - startPos - 1);
	
	mMusicVolume = volume;
	song->setMode(loop ? FMOD_LOOP_NORMAL : FMOD_LOOP_OFF);
	mSystem->playSound(FMOD_CHANNEL_FREE, song, false, &songChannel);

	songChannel->setPan(stereo);
	songChannel->setVolume(volume);
	songChannel->getFrequency(&songBaseFrequency);		//get the base frequency for modulation later
	songChannel->setPriority(0);		//the music is the top priority in SkyPaint
	// for now, just return true - of course this needs to be changed
	return true;
}

void EOSAudioDevice::listenerSetOrientationAt(float atx, float aty, float atz)
{
	_listenerOrientation[0] = atx;
	_listenerOrientation[1] = aty;
	_listenerOrientation[2] = atz;
	alListenerfv(AL_ORIENTATION, _listenerOrientation);
	checkErrors("listenerSetOrientationAt()");
}

void Connection::SendPassword()
{
	assert(m_connection);
	noidle();
	assert(!m_command_list_active);
	mpd_run_password(m_connection.get(), m_password.c_str());
	checkErrors();
}

JNIEXPORT jint JNICALL Java_org_librealsense_Native_rs2SupportsDeviceInfo
  (JNIEnv *env, jclass, jlong deviceAddr, jint cameraInfo) {
    rs2_error *error = NULL;
    rs2_device* device = (rs2_device*) deviceAddr;
    int supported = rs2_supports_device_info(device, static_cast<rs2_camera_info>(cameraInfo), &error);
    checkErrors(env, error);
    return (jint) supported;
}

JNIEXPORT jlong JNICALL Java_org_librealsense_Native_rs2GetStreamProfiles
  (JNIEnv *env, jclass, jlong sensorAddr) {
    rs2_error *error = NULL;
    rs2_sensor* sensor = (rs2_sensor*) sensorAddr;
    rs2_stream_profile_list* streamProfileList = rs2_get_stream_profiles(sensor, &error);
    checkErrors(env, error);
    return (jlong)streamProfileList;
}

JNIEXPORT jint JNICALL Java_org_librealsense_Native_rs2IsSensorExtendableTo
  (JNIEnv *env, jclass, jlong sensorAddr, jint extension) {
    rs2_error *error = NULL;
    rs2_sensor* sensor = (rs2_sensor*) sensorAddr;
    int extendable = rs2_is_sensor_extendable_to(sensor, static_cast<rs2_extension>(extension), &error);
    checkErrors(env, error);
    return (jint)extendable;
}

JNIEXPORT jlong JNICALL Java_org_librealsense_Native_rs2CreateSensor
  (JNIEnv *env, jclass, jlong sensorListAddr, jint index) {
    rs2_error *error = NULL;
    rs2_sensor_list *sensorList = (rs2_sensor_list*) sensorListAddr;
    rs2_sensor* sensor = rs2_create_sensor(sensorList, index, &error);
    checkErrors(env, error);
    return (jlong)sensor;
}

 JNIEXPORT jlong JNICALL Java_org_librealsense_Native_rs2GetFrameNumber
    (JNIEnv *env, jclass, jlong frameAddr) {
    rs2_error *error = NULL;
      rs2_frame* frame = (rs2_frame*) frameAddr;
      unsigned long long frameNumber = rs2_get_frame_number(frame, &error);
      checkErrors(env, error);
      return (jlong)frameNumber;
  }

JNIEXPORT jint JNICALL Java_org_librealsense_Native_rs2EmbeddedFramesCount
  (JNIEnv *env, jclass, jlong framesAddr) {
    rs2_error *error = NULL;
    rs2_frame* frames = (rs2_frame*) framesAddr;
    int frame_count = rs2_embedded_frames_count(frames, &error);
    checkErrors(env, error);
    return (jint)frame_count;
}