Exemple #1
0
static int
hpt_delete_array(_VBUS_ARG DEVICEID id, DWORD options)
{
	PVDevice	pArray = ID_TO_VDEV(id);
	BOOLEAN	del_block0 = (options & DAF_KEEP_DATA_IF_POSSIBLE)?0:1;
	int i;
	PVDevice pa;

	if ((id==0) || check_VDevice_valid(pArray))
		return -1;

	if(!mIsArray(pArray)) return -1;
	
	if (pArray->u.array.rf_rebuilding || pArray->u.array.rf_verifying ||
		pArray->u.array.rf_initializing)
		return -1;

	for(i=0; i<pArray->u.array.bArnMember; i++) {
		pa = pArray->u.array.pMember[i];
		if (pa && mIsArray(pa)) {
			if (pa->u.array.rf_rebuilding || pa->u.array.rf_verifying || 
				pa->u.array.rf_initializing)
				return -1;
		}
	}

	if (pArray->pVBus!=_vbus_p) { HPT_ASSERT(0); return -1;}
	fDeleteArray(_VBUS_P pArray, del_block0);
	return 0;

}
Exemple #2
0
bool gfx::Shader::CreateFromFile( const rString& Filename, GLenum ShaderType, bool print )
{
    m_Path = Filename;
    m_Type = ShaderType;
    std::ifstream fin;
    fin.open ( Filename.c_str() );
    if ( !fin.is_open() )
    {
        if ( print )
        {
			Logger::Log( "Cant open shader file " + Filename, "Shader", LogSeverity::ERROR_MSG );
        }
        return false;
    }
    rString shadertext;
    size_t found;
    rString line;
    while ( !fin.eof() )
    {
        getline ( fin, line );
        found = line.find ( "#include " );
		if ( found != rString::npos )
        {
            int i = static_cast<int> ( found ) + 9; //found + "#include "
            rString s;
            while ( i < line.length() )
            {
                s += line[i];
                i++;
            }
            rString str = GetDir ( rString ( Filename ) ) + s;
            shadertext += LoadText ( str.c_str() );
            shadertext += "\n";
        }
        else
        {
            shadertext += line;
            shadertext += '\n';
        }
    }
    fin.close();

    //create shader object
    m_Handle = glCreateShader ( ShaderType );
    if ( m_Handle == 0 )
    {
        if ( print )
        {
			Logger::Log( "Error creating shader", "Shader", LogSeverity::ERROR_MSG );
        }
    }
    const char* text = shadertext.c_str();
    glShaderSource ( m_Handle,1,&text,nullptr );

    glCompileShader ( m_Handle );
    int result = 0;
    glGetShaderiv ( m_Handle, GL_COMPILE_STATUS, &result );
    if ( result == GL_FALSE )
    {
        if ( print )
        {
			Logger::Log( "ERROR, compiling shader " + Filename, "Shader", LogSeverity::ERROR_MSG );
        }
        int length = 0;
        glGetShaderiv ( m_Handle, GL_INFO_LOG_LENGTH, &length );
        if ( length > 0 )
        {
            // create a log of error messages
            char* errorLog = fNewArray (char, length);
            int written = 0;

            glGetShaderInfoLog ( m_Handle, length, &written, errorLog );
            if ( print )
            {
				Logger::Log( "Error log: " + rString( errorLog ), "Shader", LogSeverity::ERROR_MSG );
            }
            fDeleteArray (errorLog);
        }
        return false;
    }