C++ Array::GetArray方法代码示例

Directx::TShader::TShader(const std::string& vertexSrc,const std::string& fragmentSrc,const SoyGraphics::TGeometryVertex& Vertex,const std::string& ShaderName,const std::map<std::string,std::string>& Macros,TContext& Context) :
	mBoundContext	( nullptr )
{
	auto& Device = Context.LockGetDevice();
	auto& Compiler = Context.GetCompiler();

	try
	{
		Array<uint8> VertBlob;
		Array<uint8> FragBlob;
		Compiler.Compile( GetArrayBridge(VertBlob), vertexSrc, "Vert", "vs_5_0", ShaderName + " vert shader", Macros );
		Compiler.Compile( GetArrayBridge(FragBlob), fragmentSrc, "Frag", "ps_5_0", ShaderName + " frag shader", Macros );
	
		auto Result = Device.CreateVertexShader( VertBlob.GetArray(), VertBlob.GetDataSize(), nullptr, &mVertexShader.mObject );
		Directx::IsOkay( Result, "CreateVertexShader" );

		Result = Device.CreatePixelShader( FragBlob.GetArray(), FragBlob.GetDataSize(), nullptr, &mPixelShader.mObject );
		Directx::IsOkay( Result, "CreatePixelShader" );

		MakeLayout( Vertex, GetArrayBridge(VertBlob), ShaderName, Device );
		Context.Unlock();
	}
	catch(std::exception& e)
	{
		Context.Unlock();
		throw;
	}
}

void FileStream::Write(Array<byte> data, int offset, int count) {

int dbg = fwrite(data.GetArray()+(size_t)offset,(size_t)1,(size_t)count,fpointer);
ipos +=count;
if(ipos>flen) {
flen = ipos;
}
}

Directx::TGeometry::TGeometry(const ArrayBridge<uint8>&& Data,const ArrayBridge<size_t>&& _Indexes,const SoyGraphics::TGeometryVertex& Vertex,TContext& ContextDx) :
	mVertexDescription	( Vertex ),
	mIndexCount			( 0 )
{
	Array<uint32> Indexes;
	for ( int i=0;	i<_Indexes.GetSize();	i++ )
		Indexes.PushBack( size_cast<uint32>( _Indexes[i] ) );


	// Set up the description of the static vertex buffer.
	D3D11_BUFFER_DESC vertexBufferDesc;
	vertexBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
	vertexBufferDesc.ByteWidth = Data.GetDataSize();//Vertex.GetDataSize();
	vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
	vertexBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
	vertexBufferDesc.MiscFlags = 0;
	vertexBufferDesc.StructureByteStride = Vertex.GetStride(0);	//	should be 0

	// Give the subresource structure a pointer to the vertex data.
	D3D11_SUBRESOURCE_DATA vertexData;
	vertexData.pSysMem = Data.GetArray();
	vertexData.SysMemPitch = 0;
	vertexData.SysMemSlicePitch = 0;

	// Set up the description of the static index buffer.
	D3D11_BUFFER_DESC indexBufferDesc;

	indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
	indexBufferDesc.ByteWidth = Indexes.GetDataSize();
	indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
	indexBufferDesc.CPUAccessFlags = 0;
	indexBufferDesc.MiscFlags = 0;
	indexBufferDesc.StructureByteStride = 0;

	// Give the subresource structure a pointer to the index data.
	D3D11_SUBRESOURCE_DATA indexData;
	indexData.pSysMem = Indexes.GetArray();
	indexData.SysMemPitch = 0;
	indexData.SysMemSlicePitch = 0;


	auto& Device = ContextDx.LockGetDevice();
	try
	{
		auto Result = Device.CreateBuffer(&vertexBufferDesc, &vertexData, &mVertexBuffer.mObject );
		Directx::IsOkay( Result, "Create vertex buffer");

		Result = Device.CreateBuffer(&indexBufferDesc, &indexData, &mIndexBuffer.mObject );
		Directx::IsOkay( Result, "Create index buffer");
		mIndexCount = Indexes.GetSize();
		mIndexFormat = DXGI_FORMAT_R32_UINT;
	}
	catch( std::exception& e)
	{
		ContextDx.Unlock();
		throw;
	}
}

int FileStream::Read(Array<byte> data, int offset, int count) {
size_t available;
if(flen-ipos<count) {

available = flen-ipos;
} else {
available = count;
}

int retval = (int)fread(data.GetArray()+(size_t)offset,(size_t)1,available,fpointer);
ipos = ftell(fpointer);

return retval;
}

void Directx::TShader::MakeLayout(const SoyGraphics::TGeometryVertex& Vertex,ArrayBridge<uint8>&& CompiledShader,const std::string& ShaderName,ID3D11Device& Device)
{
	Array<D3D11_INPUT_ELEMENT_DESC> Layouts;

	for ( int e=0;	e<Vertex.mElements.GetSize();	e++ )
	{
		auto& Element = Vertex.mElements[e];
		auto& Layout = Layouts.PushBack();
		memset( &Layout, 0, sizeof(Layout) );
		
		Layout.SemanticName = Element.mName.c_str();
		Layout.Format = GetType( Element.mType, Element.mArraySize );
		Layout.SemanticIndex = Element.mIndex;
		Layout.InputSlot = 0;
		Layout.AlignedByteOffset = 0;	//	D3D11_APPEND_ALIGNED_ELEMENT
		Layout.InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
		Layout.InstanceDataStepRate = 0;
	}

	auto Result = Device.CreateInputLayout( Layouts.GetArray(), Layouts.GetSize(), CompiledShader.GetArray(), CompiledShader.GetDataSize(), &mLayout.mObject );
	std::stringstream Error;
	Error << "CreateInputLayout(" << ShaderName << ")";
	Directx::IsOkay( Result, Error.str() );
}

TDecodeResult::Type TProtocolPokey::DecodeHeader(TJob& Job,TChannelStream& Stream)
{
	//	read the first byte, if it's 0xAA we know it's a reply packet
	//	if it's not, we have to assume it's a broadcast reply with an IP...
	Array<char> Data;
	auto DataBridge = GetArrayBridge(Data);
	if ( !Stream.Pop( 1, DataBridge ) )
		return TDecodeResult::Waiting;
	
	if ( static_cast<unsigned char>(Data[0]) == 0xAA )
	{
		if ( !Stream.Pop( 64-1, DataBridge ) )
		{
			Stream.UnPop(DataBridge);
			return TDecodeResult::Waiting;
		}
		
		BufferArray<unsigned char,64> UData;
		GetArrayBridge(UData).PushBackReinterpret( Data.GetArray(), Data.GetDataSize() );
		
		if ( !DecodeReply( Job, UData ) )
			return TDecodeResult::Ignore;
		
		return TDecodeResult::Success;
	}
	else
	{
		//	old protocol size 14
		//	new protocol size 19
		//	assume is broadcast reply
		if ( !Stream.Pop( 14-1, DataBridge ) )
		{
			Stream.UnPop(DataBridge);
			return TDecodeResult::Waiting;
		}

		//	gr: not sure why but have to use some data as signed and some as unsigned... not making sense to me, maybe encoding done wrong on pokey side
		BufferArray<unsigned char, 100> UData;
		GetArrayBridge(UData).PushBackReinterpret(Data.GetArray(), Data.GetDataSize());

		std::stringstream Version;
		Version << (int)UData[3] << "." << (int)UData[4];

		//	if new protocol
		bool Protocol4913 = Version.str() == "49.13";
		bool Protocol3352 = Version.str() == "33.52";
		bool Protocol4800 = Version.str() == "48.0";

		//	same protocol as newer
		Protocol4913 |= Protocol4800;

		if ( Protocol4913 )
		{
			if ( !Stream.Pop(5, DataBridge) )
			{
				Stream.UnPop(DataBridge);
				return TDecodeResult::Waiting;
			}
			UData.Clear();
			GetArrayBridge(UData).PushBackReinterpret(Data.GetArray(), Data.GetDataSize());
		}
		else if ( Protocol3352 )
		{
			
		}
		else
		{
			std::Debug << "unknown pokey protocol " << Version.str() << std::endl;
			return TDecodeResult::Ignore;
		}
		
		int Serial = 0;
		if ( Protocol4913 )
		{
			Serial = ( (int)UData[15] << 8 ) | (int)UData[14];
		}
		else if ( Protocol3352 )
		{
			Serial = ( (int)UData[1] << 8 ) | (int)UData[2];
		}

		
		std::stringstream Address;
		Address << (int)UData[5] << "." << (int)UData[6] << "." << (int)UData[7] << "." << (int)UData[8];
		Address << ":20055";
		
		std::stringstream HostAddress;
		HostAddress << (int)UData[10] << "." << (int)UData[11] << "." << (int)UData[12] << "." << (int)UData[13];
		
		Job.mParams.mCommand = TJobParams::CommandReplyPrefix + TPokeyCommand::ToString( TPokeyCommand::Discover );
		Job.mParams.AddParam("userid", static_cast<int>(UData[0]) );
		Job.mParams.AddParam("version", Version.str() );
		Job.mParams.AddParam("serial", Serial );
		Job.mParams.AddParam("dhcpenabled", static_cast<int>(UData[9]) );
		Job.mParams.AddParam("address", Address.str() );
		Job.mParams.AddParam("hostaddress", HostAddress.str() );
		return TDecodeResult::Success;
	}
}