Beispiel #1
0
  bool Place(Content<_T> content) {
     
    Sort();
    
    for( Coord::List::iterator itor = topLefts.begin(); itor != topLefts.end(); itor++ ) {
      
      content.coord = *itor;
      
      if( Fits( content ) ) {
	
	Use( content );
	topLefts.erase( itor );
	return true;
      }
    }
    
    // EXPERIMENTAL - TRY ROTATED?
    content.Rotate();
    for( Coord::List::iterator itor = topLefts.begin(); itor != topLefts.end(); itor++ ) {
      
      content.coord = *itor;
      
      if( Fits( content ) ) {
	
	Use( content );
	topLefts.erase( itor );
	return true;
      }
    }
    ////////////////////////////////
    
    
    return false;
  }
Beispiel #2
0
void Level1Algo::reset()
{
    m_boardData.assign(m_boardData.size(), 0);
    m_thisUse.assign(m_thisUse.size(), Use());
    m_peerUse.assign(m_peerUse.size(), Use());

    m_deadWinSet.clear();
    m_peerDeadWinSet.clear();

    m_isFirst = true;
}
Beispiel #3
0
void Level1Algo::init(int sz)
{
    m_sz = sz;

    m_boardData.resize(sz * sz, 0);

    WinSets_Level1::getSingletonPtr()->setEnvNxN(sz);
    int cnt = WinSets_Level1::getSingletonPtr()->getWinSetCount();
    m_thisUse.resize(cnt, Use());
    m_peerUse.resize(cnt, Use());
}
Beispiel #4
0
nResult n2dFontImpl::PrintFont(n2dGraphics2D* pGraphic, ncTStr str, nFloat x, nFloat y, nFloat scale, n2dTexture* pTexture)
{
	if (!m_pFTLib)
	{
		return NatErr_IllegalState;
	}

	nBool shouldEnd;
	auto pUsingProgram = m_pRenderer->GetShaderWrapper()->GetCurrentProgram();
	auto pFontProgram = m_pRenderer->GetShaderWrapper()->GetFontProgram();
	if (pGraphic->IsRendering())
	{
		shouldEnd = false;
		pGraphic->Flush();
	}
	else
	{
		shouldEnd = true;
		pGraphic->Begin();
	}
	m_pRenderer->PushMVPMat();
	m_pRenderer->InitMVPMat();
	auto window = m_pRenderer->GetEngine()->GetWindow();
	m_pRenderer->SubmitProjMat(natTransform::ortho(0.0f, static_cast<nFloat>(window->GetWidth()), 0.0f, static_cast<nFloat>(window->GetHeight())));
	auto scope = make_scope([shouldEnd, pGraphic, pUsingProgram, this]
	{
		if (shouldEnd)
		{
			pGraphic->End();
		}
		else
		{
			pGraphic->Flush();
		}

		m_pRenderer->PopMVPMat();
		pUsingProgram->Use();
	});

	pFontProgram->Use();
	GLint textureID = 0;
	pFontProgram->GetUniformReference(1)->SetValue(1, &textureID);
	textureID = 1;
	pFontProgram->GetUniformReference(2)->SetValue(1, &textureID);
	GLint useTexture = GL_TRUE;
	pFontProgram->GetUniformReference(3)->SetValue(1, &useTexture);

	glActiveTexture(GL_TEXTURE1);
	glBindTexture(GL_TEXTURE_2D, pTexture->GetTextureID());

	return PrintFontImpl(pGraphic, str, x, y, scale);
}
Beispiel #5
0
nResult n2dFontImpl::PrintFont(n2dGraphics2D* pGraphic, ncTStr str, nFloat x, nFloat y, nFloat scale, natVec3<> const& color)
{
	if (!m_pFTLib)
	{
		return NatErr_IllegalState;
	}

	nBool shouldEnd;
	auto pUsingProgram = m_pRenderer->GetShaderWrapper()->GetCurrentProgram();
	auto pFontProgram = m_pRenderer->GetShaderWrapper()->GetFontProgram();
	if (pGraphic->IsRendering())
	{
		shouldEnd = false;
		pGraphic->Flush();
	}
	else
	{
		shouldEnd = true;
		pGraphic->Begin();
	}
	m_pRenderer->PushMVPMat();
	m_pRenderer->InitMVPMat();
	auto window = m_pRenderer->GetEngine()->GetWindow();
	m_pRenderer->SubmitProjMat(natTransform::ortho(0.0f, static_cast<nFloat>(window->GetWidth()), 0.0f, static_cast<nFloat>(window->GetHeight())));
	auto scope = make_scope([shouldEnd, pGraphic, pUsingProgram, this]
	{
		if (shouldEnd)
		{
			pGraphic->End();
		}
		else
		{
			pGraphic->Flush();
		}

		m_pRenderer->PopMVPMat();
		pUsingProgram->Use();
	});

	pFontProgram->Use();
	GLint textureID = 0;
	GLint useTexture = GL_FALSE;
	//auto p = static_cast<n2dShaderProgramImpl::UniformReferenceImpl*>(pFontProgram->GetUniformReference(_T("textColor")));
	//m_pRenderer->GetEngine()->GetLogger().LogMsg(_T("textColor: {0}, type: {1}"), p->GetLocation(), static_cast<nuInt>(p->GetType()));
	pFontProgram->GetUniformReference(1)->SetValue(1, &textureID);
	pFontProgram->GetUniformReference(3)->SetValue(1, &useTexture);
	pFontProgram->GetUniformReference(4)->SetValue(1, &color);

	return PrintFontImpl(pGraphic, str, x, y, scale);
}
Beispiel #6
0
 void Program::Uniforms(const std::unordered_map<std::string, const glm::mat4 *> &&uniforms) {
   Use();
   for (auto &uniform : uniforms) {
     glUniformMatrix4fv(GetUniformLocation(uniform.first),
                        1, false, &uniform.second->operator[](0)[0]);
   }
 }
void OGLSpotLight::Render(double time)
{
    glClear(GL_DEPTH_BUFFER_BIT);
    glm::vec3 bgColor(0.2f);
    glClearBufferfv(GL_COLOR, 0, &bgColor[0]);

    camera.Update();
    light.position = camera.GetPosition();
    light.direction = camera.GetForwardDirection();

    // Render container
    auto programMesh = programs[0];
    programMesh->Use();

    SendLightUniform(programMesh.get());

    glm::mat4 model = glm::mat4(1);
    for (size_t i = 0; i < 10; i++) {
        float sign = (i % 2) * 2 - 1.0f;
        model = glm::mat4(1);
        model = glm::rotate(model, i * 0.2f * glm::two_pi<float>(), glm::vec3(0, 1, 0)) *
                glm::translate(model, glm::vec3(20, 0, 20));

        model = glm::scale(glm::rotate(glm::translate(glm::mat4(1), cubePositions[i]), glm::radians(sign * 30.0f), cubePositions[i]), glm::vec3(10));
        SendMatricesUniform(programMesh.get(), model);
        vaos[0]->BindVAO();
        vbos[0]->BindVBO();
        textures[0]->BindTexture(GL_TEXTURE0);
        textures[1]->BindTexture(GL_TEXTURE3);
        glUniform1f(programMesh->GetUniform("material.shininess"), 32.0f);
        glDrawArrays(GL_TRIANGLES, 0, 36);
    }
}
void Gizmo3D::Update(Vector<Node *> &editNodes)
{
    editNodes_ = &editNodes;

    Use();
    Position();
}
Beispiel #9
0
void LabelElement::Render() {
	auto m = GetMetrics();
	auto gui = GUI::Get();
	auto textProgram = ShaderRegistry::GetProgram("text");

	textProgram->Use();
	gui->camera->SetUniforms(textProgram.get());
	
	glUniform4f(textProgram->GetUniform("color"), 1,1,1, 1);

	auto size = m->topRight - m->bottomLeft;

	auto scalexy = size/textMesh->size;
	auto scale = std::min(scalexy.x, scalexy.y);
	auto tmbl = m->bottomLeft + vec2{0, textMesh->size.y * scalexy.y};

	Debug::PointUI(m->topRight);
	Debug::PointUI(m->bottomLeft);
	Debug::PointUI(m->bottomLeft + vec2{0, textMesh->size.y * scale}, vec3{1,1,0});

	Debug::PointUI(tmbl, vec3{1,0,0});
	Debug::PointUI(tmbl + textMesh->size * vec2{1,-1} * scale, vec3{0,1,0});
	Debug::PointUI(tmbl + textMesh->size * vec2{1,-1} * scale * .5f, vec3{0,0,1});

	textMesh->modelMatrix = 
		glm::translate(vec3{tmbl, 0}) *
		glm::scale(vec3{scale});

	textMesh->Render();
}
Beispiel #10
0
        bool Place(Content<_T> content)
        {
            Sort();

            for( Coord::List::iterator itor = topLefts.begin(); itor != topLefts.end(); itor++ )
            {
                content.coord = *itor;

                if( Fits( content ) )
                {
                    Use( content );
                    topLefts.erase( itor );
                    return true;
                }
            }

            return false; // yvt: BitmapAtlasGenerator doesn't support rotated contents.

            // EXPERIMENTAL - TRY ROTATED?
        //    content.Rotate();
        //    for(Coord::List::iterator itor = topLefts.begin(); itor != topLefts.end(); itor++)
        //    {
        //        content.coord = *itor;

        //        if( Fits( content ) )
        //        {
        //            Use( content );
        //            topLefts.erase( itor );
        //            return true;
        //        }
        //    }
        //    ////////////////////////////////

        //    return false;
        }
Beispiel #11
0
int main(int argc, char *argv[])
{
    int sock, x = 0;
    char *Path = argv[1], *Pro_Sea = argv[2], *Host = argv[3];

    puts("[+] NsT-phpBBDoS v0.1 by HaCkZaTaN");
    puts("[+] NeoSecurityTeam");
    puts("[+] Dos has begun....[+]\n");
    fflush(stdout);

    if(argc != 4) Use(argv[0]);

    while(1)
    {
           sock = Connection(Host,80);
           Write_In(sock, Path, Pro_Sea, Host, x);
           #ifndef WIN32
           shutdown(sock, SHUT_WR);
           close(sock);
           #else
           closesocket(sock);
           WSACleanup();
           #endif
           Pro_Sea = argv[2];
           x++;
    }
    //I don't think that it will get here =) 

    return 0;
}
Beispiel #12
0
TOD_Turn_Data::TOD_Turn_Data (void)
{
	Start (0);
	End (0);
	Use (0);
	Penalty (0);
	TOD_List (0);
}
Beispiel #13
0
void Texture::OnDraw(int x, int y) const
{
	glColor4f(1, 1, 1, 1); // Should be black?

	auto shader = _vid.GetShader(0);
	shader->Use();

	// Update parameters
	glUniform1i(shader->grad_shift_id, 0);
	float recols[] = {
		0.0, 1.0, 0.0,
		1.0, 0.0, 0.0,
	};
	glUniform3fv(shader->recolour, 2, recols);

	int *pos_id = &shader->pos_id;
	int *texcoord_id = &shader->tex_coord;

	// If there's no mask, maskid is bound to the 0 texture, so ends up being a no-op.
	glActiveTexture(GL_TEXTURE1);
	glBindTexture(GL_TEXTURE_2D, this->maskid);

	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, this->texid);

	float left = x;
	float right = x + this->width;
	float top = y;
	float bottom = y + this->height;

	float vertices[] = {
	        left,  top,    0, 0, // top-left
	        right, top,    1, 0, // top-right
	        left,  bottom, 0, 1, // bottom-left
	        right, top,    1, 0, // top-right
	        left,  bottom, 0, 1, // bottom-left
	        right, bottom, 1, 1, // bottom-right
	};

	glBindBuffer(GL_ARRAY_BUFFER, this->vbo);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_DYNAMIC_DRAW);
	glEnableVertexAttribArray(*pos_id);
	glEnableVertexAttribArray(*texcoord_id);
	glVertexAttribPointer(*pos_id,      2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void *)(0));
	glVertexAttribPointer(*texcoord_id, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void *)(2 * sizeof(float)));

	glDrawArrays(GL_TRIANGLES, 0, 6); // 2 triangles

	/* Clean up */
	glDisableVertexAttribArray(*pos_id);
	glDisableVertexAttribArray(*texcoord_id);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	shader->StopUsing();
}
void CTriggerHurt :: Spawn( void )
{
	pev->solid = SOLID_NOT;
	pev->movetype = MOVETYPE_NONE;
	UTIL_SetModel(ENT(pev), pev->model);
	UTIL_SetOrigin( this, pev->origin );
	SetBits( pev->effects, EF_NODRAW );
	m_iState = STATE_OFF;
	                            
	if (!FBitSet(pev->spawnflags, 2 )) Use( this, this, USE_ON, 0 );
}
bool OGLSpotLight::AddProgram(const std::string & vsFilename, const std::string & fsFilename)
{
    bool res = true;
    auto program = std::make_shared<gs::Program>();
    res &= program->CreateShader(GL_VERTEX_SHADER, vsFilename);
    res &= program->CreateShader(GL_FRAGMENT_SHADER, fsFilename);

    res &= program->Link();
    program->Use();
    programs.push_back(program);
    return res;
}
Beispiel #16
0
Link_Data::Link_Data (int link) : Class_Index (link)
{
	Anode (0);
	Bnode (0);
	Length (0);
	Aoffset (0);
	Boffset (0);
	Use (0);
	Type (0);
	AB_Dir (0);
	BA_Dir (0);
	Shape (0);
}
Beispiel #17
0
Link_Detail_Data::Link_Detail_Data (int link_dir) : Class_Index (link_dir)
{
	Type (0);
	Control (0);
	Left (0);
	Left_Thru (0);
	Thru (0);
	Right_Thru (0);
	Right (0);
	Use (0);
	Lanes (0);
	Period (NULL);
}
Beispiel #18
0
	void Terrain::DrawShadowMap()
	{
		auto shader = ShaderStock::GetInstance()->GetTerrainShadowShader();
		auto renderState = Device::GetInstance()->GetRenderState();
		auto shaderPrev = renderState->GetCurrentShader();

		Matrix world;
		GetWorldMatrix(&world);
		Matrix mv = world * renderState->GetViewMatrix();

		shader->Use();
		shader->UsePass(0);
		shader->SetMatrix("g_mvMatrix", mv);
		shader->SetMatrix("g_projection", renderState->GetProjectionMatrix());
		shader->SetFloat("g_zscale", this->zScale);
		shader->SetTexture("g_heightMap", this->heightMap.Get());
		shader->CommitChanges();

		DrawGeometry();

		shaderPrev->Use();
	}
Beispiel #19
0
void CFuncLight :: Spawn( void )
{	
	m_Material = matGlass;

	CBreakable::Spawn();
	SET_MODEL( edict(), GetModel() );

	// probably map compiler haven't func_light support
	if( m_iStyle <= 0 || m_iStyle >= 256 )
	{
		if( GetTargetname()[0] )
			ALERT( at_error, "%s with name %s has bad lightstyle %i. Disabled\n", GetClassname(), GetTargetname(), m_iStyle );
		else ALERT( at_error, "%s [%i] has bad lightstyle %i. Disabled\n", GetClassname(), entindex(), m_iStyle );
		m_iState = STATE_DEAD; // lamp is dead
	}
	
	if( FBitSet( pev->spawnflags, SF_LIGHT_START_ON ))
		Use( this, this, USE_ON, 0 );
	else Use( this, this, USE_OFF, 0 );

	if( pev->health <= 0 )
		pev->takedamage = DAMAGE_NO;
	else pev->takedamage = DAMAGE_YES;
}
Beispiel #20
0
const wxString wxExVCS::GetName() const
{
  if (!Use())
  {
    return wxEmptyString;
  }
  else if (wxConfigBase::Get()->ReadLong("VCS", VCS_AUTO) == VCS_AUTO)
  {
    return "Auto";
  }
  else
  {
    return m_Entry.GetName();
  }
}
Beispiel #21
0
bool wxExVCS::GetDir(wxWindow* parent)
{
  if (!Use())
  {
    return false;
  }
  
  const wxString message = _("Select VCS Folder");
  
  std::vector<wxExConfigItem> v;

  // See also vcsentry, same item is used there.
  v.push_back(wxExConfigItem(
    _("Base folder"), 
    CONFIG_COMBOBOXDIR, 
    wxEmptyString, 
    true,
    1005));
      
  if (wxExConfigFirstOf(_("Base folder")).empty()) 
  {
    if (
      parent != NULL && 
      wxExConfigDialog(parent, v, message).ShowModal() == wxID_CANCEL)
    {
      return false;
    }
  }
  else
  {
    m_Entry = FindEntry(wxExConfigFirstOf(_("Base folder")));
  
    if (m_Entry.GetName().empty())
    {
      if (
        parent != NULL &&
        wxExConfigDialog(parent, v, message).ShowModal() == wxID_CANCEL)
      {
        return false;
      }
    }
  }
  
  m_Entry = FindEntry(wxExConfigFirstOf(_("Base folder")));
  
  return !m_Entry.GetName().empty();
}
	FBTexThread(FBTexExample& example)
	 : gl()
	 , prog(make_prog(example))
	 , projection_matrix(prog, "ProjectionMatrix")
	 , camera_matrix(prog, "CameraMatrix")
	 , model_matrix(prog, "ModelMatrix")
	 , shape(List("Position")("Normal")("TexCoord").Get(), shapes::TwistedTorus(), prog)
	 , tex_side(512)
	 , parent_ready(example.parent_ready)
	{
		example.thread_ready = &thread_ready;

		Uniform<Vec3f>(prog, "LightPos").Set(20.0f, 30.0f, 40.0f);

		Texture::Active(0);
		{
			auto bound_tex = Bind(example.tex, Texture::Target::_2D);
			bound_tex.Image2D(
				0,
				PixelDataInternalFormat::RGBA,
				tex_side, tex_side,
				0,
				PixelDataFormat::RGBA,
				PixelDataType::UnsignedByte,
				nullptr
			);
			bound_tex.MinFilter(TextureMinFilter::Linear);
			bound_tex.MagFilter(TextureMagFilter::Linear);
			bound_tex.WrapS(TextureWrap::Repeat);
			bound_tex.WrapT(TextureWrap::Repeat);
		}

		{
			auto bound_fbo = Bind(fbo, Framebuffer::Target::Draw);
			auto bound_rbo = Bind(rbo, Renderbuffer::Target::Renderbuffer);

 			bound_rbo.Storage(
				PixelDataInternalFormat::DepthComponent,
				tex_side,
				tex_side
			);
			bound_fbo.AttachTexture(FramebufferAttachment::Color, example.tex, 0);
			bound_fbo.AttachRenderbuffer(FramebufferAttachment::Depth, rbo);
		}

		Use();
	}
Beispiel #23
0
DrawLineShader::DrawLineShader() : OpenGLShaderProgram("drawline")
{
    GetLocations();

    glGenBuffers(1, &_vbo);
    glGenVertexArrays(1, &_vao);

    GLuint vertices[] = { 0, 1 };
    glBindBuffer(GL_ARRAY_BUFFER, _vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glBindVertexArray(_vao);
    glEnableVertexAttribArray(vIndex);
    glVertexAttribIPointer(vIndex, 1, GL_INT, 0, nullptr);

    Use();
}
/**
* Função que obtém o erro médio quadrático de um conjunto de amostras fornecido.
*/
int BKPNeuralNet::RMS_error( float**inMatrix, float **outMatrix, int inSize, int outSize, int nSamples, float* retRMS_Error )
{
  // Casos de retorno:
  if( (!inMatrix) || (!outMatrix) || (inSize!=_nLayers[0]) || (_nLayers[_layers-1]!=outSize) )
    return -1;

  float thisOutput = 0;  
  float RMS_Error_Acum = 0;
  // Executando os treinamentos obrigatórios:
  for( int thisSample=0 ; thisSample<nSamples ; thisSample++ )
  {
    Use( inSize, inMatrix[thisSample] );
    thisOutput += OutputError(outMatrix[thisSample], outSize);
  }
  *retRMS_Error = (thisOutput/nSamples);
  return 0;
}
Beispiel #25
0
 void Graphics::SetBuffers(bool solid, bool allowInstancing)
 {
     VertexBuffer* vBuffer = activeMesh_->GetVertexBuffer();
     if (has_vertex_array_object_ext_ && !vBuffer->IsDynamic())
     {
         auto vao = VertexArrayObj::GetOrCreate(VAOKey{allowInstancing, activeProgram_, activeMesh_, solid});
         vao->Use();
     }
     else
     {
         SetVertexBuffer(vBuffer);
         SetAttributes(nullptr);
         if (allowInstancing && activeProgram_->GetMaterial()->IsBatched() && !vBuffer->IsDynamic())
             SetInstanceAttrPointers(activeProgram_);
         SetIndexBuffer(activeMesh_->GetIndexBuffer(solid));
     }
 }
Beispiel #26
0
FillRectShader::FillRectShader() : OpenGLShaderProgram("fillrect")
{
    GetLocations();

    glGenBuffers(1, &_vbo);
    glGenVertexArrays(1, &_vao);

    GLuint vertices[] = { 0, 1, 2, 2, 1, 3 };
    glBindBuffer(GL_ARRAY_BUFFER, _vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glBindVertexArray(_vao);
    glEnableVertexAttribArray(vIndex);
    glVertexAttribIPointer(vIndex, 1, GL_INT, 0, 0);

    Use();
    SetFlags(0);
    glUniform1i(uSourceFramebuffer, 0);
}
Beispiel #27
0
bool wxExVCS::SetEntryFromBase(wxWindow* parent)
{
  if (!Use())
  {
    return false;
  }
  
  const wxString message = _("Select VCS Folder");
  
  // See also vcsentry, same item is used there.
  const std::vector<wxExItem> v{{
    _("Base folder"), ITEM_COMBOBOX_DIR, wxAny(), true, wxWindow::NewControlId()}};
      
  if (wxExConfigFirstOf(_("Base folder")).empty()) 
  {
    if (
      parent != nullptr && 
      wxExItemDialog(parent, v, message).ShowModal() == wxID_CANCEL)
    {
      return false;
    }
    
    m_Entry = FindEntry(wxExConfigFirstOf(_("Base folder")));
  }
  else
  {
    m_Entry = FindEntry(wxExConfigFirstOf(_("Base folder")));
  
    if (m_Entry.GetName().empty())
    {
      if (
        parent != nullptr &&
        wxExItemDialog(parent, v, message).ShowModal() == wxID_CANCEL)
      {
        return false;
      }
      
      m_Entry = FindEntry(wxExConfigFirstOf(_("Base folder")));
    }
  }
  
  return !m_Entry.GetName().empty();
}
	FBTexExample(void)
	 : gl()
	 , vertex_shader(ObjectDesc("Vertex"))
	 , prog(make_prog())
	 , projection_matrix(prog, "ProjectionMatrix")
	 , camera_matrix(prog, "CameraMatrix")
	 , model_matrix(prog, "ModelMatrix")
	 , cube(List("Position")("Normal")("TexCoord").Get(), shapes::Cube(), prog)
	 , width(800)
	 , height(600)
	{
		UniformSampler(prog, "TexUnit").Set(0);
		Uniform<Vec3f>(prog, "LightPos").Set(40.0f, 40.0f, -80.0f);

		Texture::Active(0);
		tex.Bind(Texture::Target::_2D);

		Use();
	}
Beispiel #29
0
void CPickup::Callback_OnCollision ( CColShape& Shape, CElement& Element )
{
    if ( IS_PLAYER ( &Element ) )
    {
        CPlayer& Player = static_cast < CPlayer& > ( Element );

        // Is he alive?
        if ( !Player.IsDead () )
        {
            // Matching interior
            if ( GetInterior () == Element.GetInterior () )
            {
                // Matching dimension
                if ( GetDimension () == Element.GetDimension () )
                {
                    // Call the onPickupHit event
                    CLuaArguments Arguments;
                    Arguments.PushElement ( &Player );
                    bool bContinue1 = CallEvent ( "onPickupHit", Arguments );

                    CLuaArguments Arguments2;
                    Arguments2.PushElement ( this );       // pickup
                    bool bContinue2 = Element.CallEvent ( "onPlayerPickupHit", Arguments2 );

                    if ( bContinue1 && bContinue2 )
                    {
                        // Does it still exist?
                        if ( !IsBeingDeleted () )
                        {
                            // Can we USE the pickup?
                            if ( CanUse ( Player ) )
                            {
                                // USE the pickup
                                Use ( Player );
                            }
                        }
                    }
                }
            }
        }
    }
}
//-----------------------------------------------------------------------------
// Purpose: allows the crate to open up when hit by a crowbar
//-----------------------------------------------------------------------------
int CItem_AmmoCrate::OnTakeDamage( const CTakeDamageInfo &info )
{
	// if it's the player hitting us with a crowbar, open up
	CBasePlayer *player = ToBasePlayer(info.GetAttacker());
	if (player)
	{
		CBaseCombatWeapon *weapon = player->GetActiveWeapon();

		if (weapon && !stricmp(weapon->GetName(), "weapon_crowbar"))
		{
			// play the normal use sound
			player->EmitSound( "HL2Player.Use" );
			// open the crate
			Use(info.GetAttacker(), info.GetAttacker(), USE_TOGGLE, 0.0f);
		}
	}

	// don't actually take any damage
	return 0;
}