diff options
Diffstat (limited to 'o3d')
44 files changed, 4607 insertions, 1914 deletions
diff --git a/o3d/command_buffer/client/cross/big_test_client.cc b/o3d/command_buffer/client/cross/big_test_client.cc index cf42ee5..568b81f 100644 --- a/o3d/command_buffer/client/cross/big_test_client.cc +++ b/o3d/command_buffer/client/cross/big_test_client.cc @@ -47,30 +47,6 @@ namespace command_buffer { namespace math = Vectormath::Aos; -// Adds a Clear command into the command buffer. -// Parameters: -// cmd_buffer: the command buffer helper. -// buffers: a bitfield of which buffers to clear (a combination of -// GAPIInterface::COLOR, GAPIInterface::DEPTH and GAPIInterface::STENCIL). -// color: the color buffer clear value. -// depth: the depth buffer clear value. -// stencil: the stencil buffer clear value. -void ClearCmd(CommandBufferHelper *cmd_buffer, - const unsigned int buffers, - const RGBA &color, - float depth, - unsigned int stencil) { - CommandBufferEntry args[7]; - args[0].value_uint32 = buffers; - args[1].value_float = color.red; - args[2].value_float = color.green; - args[3].value_float = color.blue; - args[4].value_float = color.alpha; - args[5].value_float = depth; - args[6].value_uint32 = stencil; - cmd_buffer->AddCommand(command_buffer::CLEAR, 7, args); -} - // Adds a SetViewport command into the buffer. // Parameters: // cmd_buffer: the command buffer helper. @@ -83,14 +59,7 @@ void SetViewportCmd(CommandBufferHelper *cmd_buffer, unsigned int height, float z_near, float z_far) { - CommandBufferEntry args[6]; - args[0].value_uint32 = x; - args[1].value_uint32 = y; - args[2].value_uint32 = width; - args[3].value_uint32 = height; - args[4].value_float = z_near; - args[5].value_float = z_far; - cmd_buffer->AddCommand(command_buffer::SET_VIEWPORT, 6, args); + cmd_buffer->SetViewport(x, y, width, height, z_near, z_far); } // Copy a data buffer to args, for IMMEDIATE commands. Returns the number of @@ -143,88 +112,51 @@ void BigTestClient(nacl::HtpHandle handle) { // Clear the buffers. RGBA color = {0.2f, 0.2f, 0.2f, 1.f}; - ClearCmd(&cmd_buffer, GAPIInterface::COLOR | GAPIInterface::DEPTH, color, - 1.f, 0); + cmd_buffer.Clear(GAPIInterface::COLOR | GAPIInterface::DEPTH, + color.red, color.green, color.blue, color.alpha, + 1.f, 0); const ResourceID vertex_buffer_id = 1; const ResourceID vertex_struct_id = 1; - // AddCommand copies the args, so it is safe to re-use args across various - // calls. - // 20 is the largest command we use (SET_PARAM_DATA_IMMEDIATE for matrices). - CommandBufferEntry args[20]; - - CustomVertex vertices[4] = { + static const CustomVertex vertices[4] = { {-.5f, -.5f, 0.f, 1.f, 0, 0}, {.5f, -.5f, 0.f, 1.f, 1, 0}, {-.5f, .5f, 0.f, 1.f, 0, 1}, {.5f, .5f, 0.f, 1.f, 1, 1}, }; - args[0].value_uint32 = vertex_buffer_id; - args[1].value_uint32 = sizeof(vertices); // size - args[2].value_uint32 = 0; // flags - cmd_buffer.AddCommand(command_buffer::CREATE_VERTEX_BUFFER, 3, args); + cmd_buffer.CreateVertexBuffer(vertex_buffer_id, sizeof(vertices), 0); memcpy(shm_address, vertices, sizeof(vertices)); - args[0].value_uint32 = vertex_buffer_id; - args[1].value_uint32 = 0; // offset in VB - args[2].value_uint32 = sizeof(vertices); // size - args[3].value_uint32 = shm_id; // shm - args[4].value_uint32 = 0; // offset in shm - cmd_buffer.AddCommand(command_buffer::SET_VERTEX_BUFFER_DATA, 5, args); + cmd_buffer.SetVertexBufferData( + vertex_buffer_id, 0, sizeof(vertices), shm_id, 0); unsigned int token = cmd_buffer.InsertToken(); - args[0].value_uint32 = vertex_struct_id; - args[1].value_uint32 = 2; // input count - cmd_buffer.AddCommand(command_buffer::CREATE_VERTEX_STRUCT, 2, args); + cmd_buffer.CreateVertexStruct(vertex_struct_id, 2); // Set POSITION input stream - args[0].value_uint32 = vertex_struct_id; - args[1].value_uint32 = 0; // input - args[2].value_uint32 = vertex_buffer_id; // buffer - args[3].value_uint32 = 0; // offset - args[4].value_uint32 = - set_vertex_input_cmd::Stride::MakeValue(sizeof(CustomVertex)) | - set_vertex_input_cmd::Type::MakeValue(vertex_struct::FLOAT4) | - set_vertex_input_cmd::Semantic::MakeValue(vertex_struct::POSITION) | - set_vertex_input_cmd::SemanticIndex::MakeValue(0); - cmd_buffer.AddCommand(command_buffer::SET_VERTEX_INPUT, 5, args); + cmd_buffer.SetVertexInput(vertex_struct_id, 0, vertex_buffer_id, 0, + vertex_struct::POSITION, 0, + vertex_struct::FLOAT4, sizeof(CustomVertex)); // Set TEXCOORD0 input stream - args[1].value_uint32 = 1; // input - args[3].value_uint32 = 16; // offset - args[4].value_uint32 = - set_vertex_input_cmd::Stride::MakeValue(sizeof(CustomVertex)) | - set_vertex_input_cmd::Type::MakeValue(vertex_struct::FLOAT2) | - set_vertex_input_cmd::Semantic::MakeValue(vertex_struct::TEX_COORD) | - set_vertex_input_cmd::SemanticIndex::MakeValue(0); - cmd_buffer.AddCommand(command_buffer::SET_VERTEX_INPUT, 5, args); + cmd_buffer.SetVertexInput(vertex_struct_id, 1, vertex_buffer_id, 16, + vertex_struct::TEX_COORD, 0, + vertex_struct::FLOAT2, sizeof(CustomVertex)); // wait for previous transfer to be executed, so that we can re-use the // transfer shared memory buffer. cmd_buffer.WaitForToken(token); memcpy(shm_address, effect_data, sizeof(effect_data)); const ResourceID effect_id = 1; - args[0].value_uint32 = effect_id; - args[1].value_uint32 = sizeof(effect_data); // size - args[2].value_uint32 = shm_id; // shm - args[3].value_uint32 = 0; // offset in shm - cmd_buffer.AddCommand(command_buffer::CREATE_EFFECT, 4, args); + cmd_buffer.CreateEffect(effect_id, sizeof(effect_data), shm_id, 0); token = cmd_buffer.InsertToken(); // Create a 4x4 2D texture. const ResourceID texture_id = 1; - args[0].value_uint32 = texture_id; - args[1].value_uint32 = - create_texture_2d_cmd::Width::MakeValue(4) | - create_texture_2d_cmd::Height::MakeValue(4); - args[2].value_uint32 = - create_texture_2d_cmd::Levels::MakeValue(0) | - create_texture_2d_cmd::Format::MakeValue(texture::ARGB8) | - create_texture_2d_cmd::Flags::MakeValue(0); - cmd_buffer.AddCommand(command_buffer::CREATE_TEXTURE_2D, 3, args); - - unsigned int texels[4] = { + cmd_buffer.CreateTexture2d(texture_id, 4, 4, 1, texture::ARGB8, 0); + + static const unsigned int texels[4] = { 0xff0000ff, 0xffff00ff, 0xff00ffff, @@ -237,68 +169,40 @@ void BigTestClient(nacl::HtpHandle handle) { // Creates a 4x4 texture by uploading 2x2 data in each quadrant. for (unsigned int x = 0; x < 2; ++x) for (unsigned int y = 0; y < 2; ++y) { - args[0].value_uint32 = texture_id; - args[1].value_uint32 = - set_texture_data_cmd::X::MakeValue(x*2) | - set_texture_data_cmd::Y::MakeValue(y*2); - args[2].value_uint32 = - set_texture_data_cmd::Width::MakeValue(2) | - set_texture_data_cmd::Height::MakeValue(2); - args[3].value_uint32 = - set_texture_data_cmd::Z::MakeValue(0) | - set_texture_data_cmd::Depth::MakeValue(1); - args[4].value_uint32 = set_texture_data_cmd::Level::MakeValue(0); - args[5].value_uint32 = sizeof(texels[0]) * 2; // row_pitch - args[6].value_uint32 = 0; // slice_pitch - args[7].value_uint32 = sizeof(texels); // size - args[8].value_uint32 = shm_id; - args[9].value_uint32 = 0; - cmd_buffer.AddCommand(command_buffer::SET_TEXTURE_DATA, 10, args); + cmd_buffer.SetTextureData(texture_id, x * 2, y * 2, 0, 2, 2, 1, 0, 0, + sizeof(texels[0]) * 2, // row_pitch + 0, // slice_pitch + sizeof(texels), // size + shm_id, + 0); } token = cmd_buffer.InsertToken(); const ResourceID sampler_id = 1; - args[0].value_uint32 = sampler_id; - cmd_buffer.AddCommand(command_buffer::CREATE_SAMPLER, 1, args); - - args[0].value_uint32 = sampler_id; - args[1].value_uint32 = texture_id; - cmd_buffer.AddCommand(command_buffer::SET_SAMPLER_TEXTURE, 2, args); - - args[0].value_uint32 = sampler_id; - args[1].value_uint32 = - set_sampler_states::AddressingU::MakeValue(sampler::CLAMP_TO_EDGE) | - set_sampler_states::AddressingV::MakeValue(sampler::CLAMP_TO_EDGE) | - set_sampler_states::AddressingW::MakeValue(sampler::CLAMP_TO_EDGE) | - set_sampler_states::MagFilter::MakeValue(sampler::POINT) | - set_sampler_states::MinFilter::MakeValue(sampler::POINT) | - set_sampler_states::MipFilter::MakeValue(sampler::NONE) | - set_sampler_states::MaxAnisotropy::MakeValue(1); - cmd_buffer.AddCommand(command_buffer::SET_SAMPLER_STATES, 2, args); + cmd_buffer.CreateSampler(sampler_id); + cmd_buffer.SetSamplerTexture(sampler_id, texture_id); + cmd_buffer.SetSamplerStates(sampler_id, + sampler::CLAMP_TO_EDGE, + sampler::CLAMP_TO_EDGE, + sampler::CLAMP_TO_EDGE, + sampler::POINT, + sampler::POINT, + sampler::NONE, + 1); // Create a parameter for the sampler. const ResourceID sampler_param_id = 1; { - const char param_name[] = "s0"; - args[0].value_uint32 = sampler_param_id; - args[1].value_uint32 = effect_id; - args[2].value_uint32 = sizeof(param_name); - unsigned int arg_count = CopyToArgs(args + 3, param_name, - sizeof(param_name)); - cmd_buffer.AddCommand(command_buffer::CREATE_PARAM_BY_NAME_IMMEDIATE, - 3 + arg_count, args); + static const char param_name[] = "s0"; + cmd_buffer.CreateParamByNameImmediate(sampler_param_id, effect_id, + sizeof(param_name), param_name); } const ResourceID matrix_param_id = 2; { - const char param_name[] = "worldViewProj"; - args[0].value_uint32 = matrix_param_id; - args[1].value_uint32 = effect_id; - args[2].value_uint32 = sizeof(param_name); - unsigned int arg_count = CopyToArgs(args + 3, param_name, - sizeof(param_name)); - cmd_buffer.AddCommand(command_buffer::CREATE_PARAM_BY_NAME_IMMEDIATE, - 3 + arg_count, args); + static const char param_name[] = "worldViewProj"; + cmd_buffer.CreateParamByNameImmediate(matrix_param_id, effect_id, + sizeof(param_name), param_name); } float t = 0.f; @@ -307,34 +211,21 @@ void BigTestClient(nacl::HtpHandle handle) { math::Matrix4 m = math::Matrix4::translation(math::Vector3(0.f, 0.f, .5f)); m *= math::Matrix4::rotationY(t * 2 * 3.1415926f); - cmd_buffer.AddCommand(command_buffer::BEGIN_FRAME, 0 , NULL); + cmd_buffer.BeginFrame(); // Clear the background with an animated color (black to red). - ClearCmd(&cmd_buffer, GAPIInterface::COLOR | GAPIInterface::DEPTH, color, - 1.f, 0); - - args[0].value_uint32 = vertex_struct_id; - cmd_buffer.AddCommand(command_buffer::SET_VERTEX_STRUCT, 1, args); - - args[0].value_uint32 = effect_id; - cmd_buffer.AddCommand(command_buffer::SET_EFFECT, 1, args); - - args[0].value_uint32 = sampler_param_id; - args[1].value_uint32 = sizeof(Uint32); // NOLINT - args[2].value_uint32 = sampler_id; - cmd_buffer.AddCommand(command_buffer::SET_PARAM_DATA_IMMEDIATE, 3, args); - - args[0].value_uint32 = matrix_param_id; - args[1].value_uint32 = sizeof(m); - unsigned int arg_count = CopyToArgs(args + 2, &m, sizeof(m)); - cmd_buffer.AddCommand(command_buffer::SET_PARAM_DATA_IMMEDIATE, - 2 + arg_count, args); - - args[0].value_uint32 = GAPIInterface::TRIANGLE_STRIPS; - args[1].value_uint32 = 0; // first - args[2].value_uint32 = 2; // primitive count - cmd_buffer.AddCommand(command_buffer::DRAW, 3, args); - - cmd_buffer.AddCommand(command_buffer::END_FRAME, 0 , NULL); + cmd_buffer.Clear(GAPIInterface::COLOR | GAPIInterface::DEPTH, + color.red, color.green, color.blue, color.alpha, + 1.f, 0); + + cmd_buffer.SetVertexStruct(vertex_struct_id); + cmd_buffer.SetEffect(effect_id); + cmd_buffer.SetParamDataImmediate( + sampler_param_id, sizeof(uint32), &sampler_id); // NOLINT + cmd_buffer.SetParamDataImmediate( + matrix_param_id, sizeof(m), &m); + cmd_buffer.Draw(GAPIInterface::TRIANGLE_STRIPS, 0, 2); + + cmd_buffer.EndFrame(); cmd_buffer.Flush(); } diff --git a/o3d/command_buffer/client/cross/buffer_sync_proxy_test.cc b/o3d/command_buffer/client/cross/buffer_sync_proxy_test.cc index 790a693..f19c6bf 100644 --- a/o3d/command_buffer/client/cross/buffer_sync_proxy_test.cc +++ b/o3d/command_buffer/client/cross/buffer_sync_proxy_test.cc @@ -229,7 +229,7 @@ TEST_F(BufferSyncProxyTest, TestSignalGetChanges) { // message and returns the correct value. TEST_F(BufferSyncProxyTest, TestGetStatus) { RPCSendInterfaceMock::SendCallExpect expect; - expect._return = BufferSyncInterface::PARSING; + expect._return = BufferSyncInterface::kParsing; expect.message_id = BufferRPCImpl::GET_STATUS; expect.data = NULL; expect.size = 0; @@ -237,14 +237,14 @@ TEST_F(BufferSyncProxyTest, TestGetStatus) { expect.handle_count = 0; server_mock()->AddSendCallExpect(expect); - EXPECT_EQ(BufferSyncInterface::PARSING, proxy()->GetStatus()); + EXPECT_EQ(BufferSyncInterface::kParsing, proxy()->GetStatus()); } // Tests the implementation of GetParseError, checking that it sends the correct // message and returns the correct value. TEST_F(BufferSyncProxyTest, TestGetParseError) { RPCSendInterfaceMock::SendCallExpect expect; - expect._return = BufferSyncInterface::PARSE_UNKNOWN_COMMAND; + expect._return = BufferSyncInterface::kParseUnknownCommand; expect.message_id = BufferRPCImpl::GET_PARSE_ERROR; expect.data = NULL; expect.size = 0; @@ -252,7 +252,7 @@ TEST_F(BufferSyncProxyTest, TestGetParseError) { expect.handle_count = 0; server_mock()->AddSendCallExpect(expect); - EXPECT_EQ(BufferSyncInterface::PARSE_UNKNOWN_COMMAND, + EXPECT_EQ(BufferSyncInterface::kParseUnknownCommand, proxy()->GetParseError()); } diff --git a/o3d/command_buffer/client/cross/cmd_buffer_helper.cc b/o3d/command_buffer/client/cross/cmd_buffer_helper.cc index f844576..209f297 100644 --- a/o3d/command_buffer/client/cross/cmd_buffer_helper.cc +++ b/o3d/command_buffer/client/cross/cmd_buffer_helper.cc @@ -43,7 +43,7 @@ CommandBufferHelper::CommandBufferHelper(BufferSyncInterface *interface) entry_count_(0), token_(0) { // The interface should be connected already. - DCHECK_NE(BufferSyncInterface::NOT_CONNECTED, interface_->GetStatus()); + DCHECK_NE(BufferSyncInterface::kNotConnected, interface_->GetStatus()); } bool CommandBufferHelper::Init(unsigned int entry_count) { @@ -94,7 +94,7 @@ unsigned int CommandBufferHelper::InsertToken() { ++token_; CommandBufferEntry args; args.value_uint32 = token_; - AddCommand(SET_TOKEN, 1, &args); + AddCommand(command_buffer::kSetToken, 1, &args); if (token_ == 0) { // we wrapped Finish(); @@ -129,20 +129,20 @@ void CommandBufferHelper::WaitForGetChange() { // If get_ didn't change or is invalid (-1), it means an error may have // occured. Check that. BufferSyncInterface::ParserStatus status = interface_->GetStatus(); - if (status != BufferSyncInterface::PARSING) { + if (status != BufferSyncInterface::kParsing) { switch (status) { - case BufferSyncInterface::NOT_CONNECTED: + case BufferSyncInterface::kNotConnected: LOG(FATAL) << "Service disconnected."; return; - case BufferSyncInterface::NO_BUFFER: + case BufferSyncInterface::kNoBuffer: LOG(FATAL) << "Service doesn't have a buffer set."; return; - case BufferSyncInterface::PARSE_ERROR: { + case BufferSyncInterface::kParseError: { BufferSyncInterface::ParseError error = interface_->GetParseError(); LOG(WARNING) << "Parse error: " << error; return; } - case BufferSyncInterface::PARSING: + case BufferSyncInterface::kParsing: break; } } @@ -181,5 +181,12 @@ void CommandBufferHelper::WaitForAvailableEntries(unsigned int count) { while (AvailableEntries() < count) WaitForGetChange(); } +CommandBufferEntry* CommandBufferHelper::GetSpace(uint32 entries) { + WaitForAvailableEntries(entries); + CommandBufferEntry* space = &entries_[put_]; + put_ += entries; + return space; +} + } // namespace command_buffer } // namespace o3d diff --git a/o3d/command_buffer/client/cross/cmd_buffer_helper.h b/o3d/command_buffer/client/cross/cmd_buffer_helper.h index 775835b..8e13555 100644 --- a/o3d/command_buffer/client/cross/cmd_buffer_helper.h +++ b/o3d/command_buffer/client/cross/cmd_buffer_helper.h @@ -90,6 +90,27 @@ class CommandBufferHelper { // the size of the buffer minus one. void WaitForAvailableEntries(unsigned int count); + // Adds a command data to the command buffer. This may wait until sufficient + // space is available. + // Parameters: + // entries: The command entries to add. + // count: The number of entries. + void AddCommandData(const CommandBufferEntry* entries, unsigned int count) { + WaitForAvailableEntries(count); + for (; count > 0; --count) { + entries_[put_++] = *entries++; + } + DCHECK_LE(put_, entry_count_); + if (put_ == entry_count_) put_ = 0; + } + + // A typed version of AddCommandData. + template <typename T> + void AddTypedCmdData(const T& cmd) { + AddCommandData(reinterpret_cast<const CommandBufferEntry*>(&cmd), + ComputeNumEntries(sizeof(cmd))); + } + // Adds a command to the command buffer. This may wait until sufficient space // is available. // Parameters: @@ -99,7 +120,7 @@ class CommandBufferHelper { // function returns). void AddCommand(unsigned int command, unsigned int arg_count, - CommandBufferEntry *args) { + const CommandBufferEntry *args) { CommandHeader header; header.size = arg_count + 1; header.command = command; @@ -130,13 +151,612 @@ class CommandBufferHelper { // Returns the buffer interface used to send synchronous commands. BufferSyncInterface *interface() { return interface_; } + // Waits for a certain amount of space to be available. Returns address + // of space. + CommandBufferEntry* GetSpace(uint32 entries); + + // Typed version of GetSpace. Gets enough room for the given type and returns + // a reference to it. + template <typename T> + T& GetCmdSpace() { + COMPILE_ASSERT(T::kArgFlags == cmd::kFixed, Cmd_kArgFlags_not_kFixed); + uint32 space_needed = ComputeNumEntries(sizeof(T)); + void* data = GetSpace(space_needed); + return *reinterpret_cast<T*>(data); + } + + // Typed version of GetSpace for immediate commands. + template <typename T> + T& GetImmediateCmdSpace(size_t space) { + COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); + uint32 space_needed = ComputeNumEntries(sizeof(T) + space); + void* data = GetSpace(space_needed); + return *reinterpret_cast<T*>(data); + } + + // ------------------ Individual commands ---------------------- + + void Noop(uint32 skip_count) { + cmd::Noop& cmd = GetImmediateCmdSpace<cmd::Noop>( + skip_count * sizeof(CommandBufferEntry)); + cmd.Init(skip_count); + } + + + void SetToken(uint32 token) { + cmd::SetToken& cmd = GetCmdSpace<cmd::SetToken>(); + cmd.Init(token); + } + + + void BeginFrame() { + cmd::BeginFrame& cmd = GetCmdSpace<cmd::BeginFrame>(); + cmd.Init(); + } + + + void EndFrame() { + cmd::EndFrame& cmd = GetCmdSpace<cmd::EndFrame>(); + cmd.Init(); + } + + void Clear( + uint32 buffers, + float red, float green, float blue, float alpha, + float depth, uint32 stencil) { + cmd::Clear& cmd = GetCmdSpace<cmd::Clear>(); + cmd.Init(buffers, red, green, blue, alpha, depth, stencil); + } + + void SetViewport( + uint32 left, + uint32 top, + uint32 width, + uint32 height, + float z_min, + float z_max) { + cmd::SetViewport& cmd = GetCmdSpace<cmd::SetViewport>(); + cmd.Init(left, top, width, height, z_min, z_max); + } + + void CreateVertexBuffer(uint32 id, uint32 size, uint32 flags) { + cmd::CreateVertexBuffer& cmd = GetCmdSpace<cmd::CreateVertexBuffer>(); + cmd.Init(id, size, flags); + } + + void DestroyVertexBuffer(uint32 id) { + cmd::DestroyVertexBuffer& cmd = GetCmdSpace<cmd::DestroyVertexBuffer>(); + cmd.Init(id); + } + + void SetVertexBufferDataImmediate( + uint32 id, uint32 offset, + const void* data, uint32 size) { + cmd::SetVertexBufferDataImmediate& cmd = + GetImmediateCmdSpace<cmd::SetVertexBufferDataImmediate>(size); + cmd.Init(id, offset, data, size); + } + + void SetVertexBufferData( + uint32 id, uint32 offset, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + cmd::SetVertexBufferData& cmd = + GetCmdSpace<cmd::SetVertexBufferData>(); + cmd.Init(id, offset, size, + shared_memory_id, shared_memory_offset); + } + + void GetVertexBufferData( + uint32 id, uint32 offset, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + cmd::GetVertexBufferData& cmd = + GetCmdSpace<cmd::GetVertexBufferData>(); + cmd.Init(id, offset, size, + shared_memory_id, shared_memory_offset); + } + + void CreateIndexBuffer(uint32 id, uint32 size, uint32 flags) { + cmd::CreateIndexBuffer& cmd = + GetCmdSpace<cmd::CreateIndexBuffer>(); + cmd.Init(id, size, flags); + } + + void DestroyIndexBuffer(uint32 id) { + cmd::DestroyIndexBuffer& cmd = GetCmdSpace<cmd::DestroyIndexBuffer>(); + cmd.Init(id); + } + + void SetIndexBufferDataImmediate( + uint32 id, uint32 offset, const void* data, uint32 size) { + cmd::SetIndexBufferDataImmediate& cmd = + GetImmediateCmdSpace<cmd::SetIndexBufferDataImmediate>(size); + cmd.Init(id, offset, data, size); + } + + void SetIndexBufferData( + uint32 id, uint32 offset, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + cmd::SetIndexBufferData& cmd = GetCmdSpace<cmd::SetIndexBufferData>(); + cmd.Init(id, offset, size, shared_memory_id, shared_memory_offset); + } + + void GetIndexBufferData( + uint32 id, uint32 offset, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + cmd::GetIndexBufferData& cmd = GetCmdSpace<cmd::GetIndexBufferData>(); + cmd.Init(id, offset, size, shared_memory_id, shared_memory_offset); + } + + void CreateVertexStruct(uint32 id, uint32 input_count) { + cmd::CreateVertexStruct& cmd = GetCmdSpace<cmd::CreateVertexStruct>(); + cmd.Init(id, input_count); + } + + void DestroyVertexStruct(uint32 id) { + cmd::DestroyVertexStruct& cmd = GetCmdSpace<cmd::DestroyVertexStruct>(); + cmd.Init(id); + } + + void SetVertexInput( + uint32 vertex_struct_id, + uint32 input_index, + uint32 vertex_buffer_id, + uint32 offset, + uint8 semantic, + uint32 semantic_index, + uint8 type, + uint32 stride) { + cmd::SetVertexInput& cmd = GetCmdSpace<cmd::SetVertexInput>(); + cmd.Init( + vertex_struct_id, + input_index, + vertex_buffer_id, + offset, + semantic, + semantic_index, + type, + stride); + } + + void SetVertexStruct(uint32 id) { + cmd::SetVertexStruct& cmd = GetCmdSpace<cmd::SetVertexStruct>(); + cmd.Init(id); + } + + void Draw(uint32 primitive_type, uint32 first, uint32 count) { + cmd::Draw& cmd = GetCmdSpace<cmd::Draw>(); + cmd.Init(primitive_type, first, count); + } + + void DrawIndexed( + uint32 primitive_type, + uint32 index_buffer_id, + uint32 first, + uint32 count, + uint32 min_index, + uint32 max_index) { + cmd::DrawIndexed& cmd = GetCmdSpace<cmd::DrawIndexed>(); + cmd.Init( + primitive_type, + index_buffer_id, + first, + count, + min_index, + max_index); + } + + void CreateEffect( + uint32 id, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + cmd::CreateEffect& cmd = GetCmdSpace<cmd::CreateEffect>(); + cmd.Init(id, size, shared_memory_id, shared_memory_offset); + } + + void CreateEffectImmediate(uint32 id, uint32 size, const void* data) { + cmd::CreateEffectImmediate& cmd = + GetImmediateCmdSpace<cmd::CreateEffectImmediate>(size); + cmd.Init(id, size, data); + } + + void DestroyEffect(uint32 id) { + cmd::DestroyEffect& cmd = GetCmdSpace<cmd::DestroyEffect>(); + cmd.Init(id); + } + + void SetEffect(uint32 id) { + cmd::SetEffect& cmd = GetCmdSpace<cmd::SetEffect>(); + cmd.Init(id); + } + + void GetParamCount( + uint32 id, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + cmd::GetParamCount& cmd = GetCmdSpace<cmd::GetParamCount>(); + cmd.Init(id, size, shared_memory_id, shared_memory_offset); + } + + void CreateParam(uint32 param_id, uint32 effect_id, uint32 index) { + cmd::CreateParam& cmd = GetCmdSpace<cmd::CreateParam>(); + cmd.Init(param_id, effect_id, index); + } + + void CreateParamByName( + uint32 param_id, uint32 effect_id, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + cmd::CreateParamByName& cmd = GetCmdSpace<cmd::CreateParamByName>(); + cmd.Init(param_id, effect_id, size, shared_memory_id, shared_memory_offset); + } + + void CreateParamByNameImmediate( + uint32 param_id, uint32 effect_id, uint32 size, const void* data) { + cmd::CreateParamByNameImmediate& cmd = + GetImmediateCmdSpace<cmd::CreateParamByNameImmediate>(size); + cmd.Init(param_id, effect_id, size, data); + } + + void DestroyParam(uint32 id) { + cmd::DestroyParam& cmd = GetCmdSpace<cmd::DestroyParam>(); + cmd.Init(id); + } + + void SetParamData( + uint32 id, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + cmd::SetParamData& cmd = GetCmdSpace<cmd::SetParamData>(); + cmd.Init(id, size, shared_memory_id, shared_memory_offset); + } + + void SetParamDataImmediate(uint32 id, uint32 size, const void* data) { + cmd::SetParamDataImmediate& cmd = + GetImmediateCmdSpace<cmd::SetParamDataImmediate>(size); + cmd.Init(id, size, data); + } + + void GetParamDesc( + uint32 id, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + cmd::GetParamDesc& cmd = GetCmdSpace<cmd::GetParamDesc>(); + cmd.Init(id, size, shared_memory_id, shared_memory_offset); + } + + void GetStreamCount( + uint32 id, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + cmd::GetStreamCount& cmd = GetCmdSpace<cmd::GetStreamCount>(); + cmd.Init(id, size, shared_memory_id, shared_memory_offset); + } + + void GetStreamDesc( + uint32 id, uint32 index, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + cmd::GetStreamDesc& cmd = GetCmdSpace<cmd::GetStreamDesc>(); + cmd.Init(id, index, size, shared_memory_id, shared_memory_offset); + } + + void DestroyTexture(uint32 id) { + cmd::DestroyTexture& cmd = GetCmdSpace<cmd::DestroyTexture>(); + cmd.Init(id); + } + + void CreateTexture2d( + uint32 texture_id, + uint32 width, uint32 height, + uint32 levels, uint32 format, + uint32 enable_render_surfaces) { + cmd::CreateTexture2d& cmd = GetCmdSpace<cmd::CreateTexture2d>(); + cmd.Init(texture_id, + width, height, levels, format, + enable_render_surfaces); + } + + void CreateTexture3d( + uint32 texture_id, + uint32 width, uint32 height, uint32 depth, + uint32 levels, uint32 format, + uint32 enable_render_surfaces) { + cmd::CreateTexture3d& cmd = GetCmdSpace<cmd::CreateTexture3d>(); + cmd.Init(texture_id, + width, height, depth, + levels, format, + enable_render_surfaces); + } + + void CreateTextureCube( + uint32 texture_id, + uint32 edge_length, uint32 levels, uint32 format, + uint32 enable_render_surfaces) { + cmd::CreateTextureCube& cmd = GetCmdSpace<cmd::CreateTextureCube>(); + cmd.Init(texture_id, + edge_length, levels, format, + enable_render_surfaces); + } + + void SetTextureData( + uint32 texture_id, + uint32 x, + uint32 y, + uint32 z, + uint32 width, + uint32 height, + uint32 depth, + uint32 level, + uint32 face, + uint32 row_pitch, + uint32 slice_pitch, + uint32 size, + uint32 shared_memory_id, + uint32 shared_memory_offset) { + cmd::SetTextureData& cmd = GetCmdSpace<cmd::SetTextureData>(); + cmd.Init( + texture_id, + x, + y, + z, + width, + height, + depth, + level, + face, + row_pitch, + slice_pitch, + size, + shared_memory_id, + shared_memory_offset); + } + + void SetTextureDataImmediate( + uint32 texture_id, + uint32 x, + uint32 y, + uint32 z, + uint32 width, + uint32 height, + uint32 depth, + uint32 level, + uint32 face, + uint32 row_pitch, + uint32 slice_pitch, + uint32 size, + const void* data) { + cmd::SetTextureDataImmediate& cmd = + GetImmediateCmdSpace<cmd::SetTextureDataImmediate>(size); + cmd.Init( + texture_id, + x, + y, + z, + width, + height, + depth, + level, + face, + row_pitch, + slice_pitch, + size, + data); + } + + void GetTextureData( + uint32 texture_id, + uint32 x, + uint32 y, + uint32 z, + uint32 width, + uint32 height, + uint32 depth, + uint32 level, + uint32 face, + uint32 row_pitch, + uint32 slice_pitch, + uint32 size, + uint32 shared_memory_id, + uint32 shared_memory_offset) { + cmd::GetTextureData& cmd = GetCmdSpace<cmd::GetTextureData>(); + cmd.Init( + texture_id, + x, + y, + z, + width, + height, + depth, + level, + face, + row_pitch, + slice_pitch, + size, + shared_memory_id, + shared_memory_offset); + } + + void CreateSampler(uint32 id) { + cmd::CreateSampler& cmd = GetCmdSpace<cmd::CreateSampler>(); + cmd.Init(id); + } + + void DestroySampler(uint32 id) { + cmd::DestroySampler& cmd = GetCmdSpace<cmd::DestroySampler>(); + cmd.Init(id); + } + + void SetSamplerStates(uint32 id, + uint32 address_u_value, + uint32 address_v_value, + uint32 address_w_value, + uint32 mag_filter_value, + uint32 min_filter_value, + uint32 mip_filter_value, + uint32 max_anisotropy) { + cmd::SetSamplerStates& cmd = GetCmdSpace<cmd::SetSamplerStates>(); + cmd.Init( + id, + address_u_value, + address_v_value, + address_w_value, + mag_filter_value, + min_filter_value, + mip_filter_value, + max_anisotropy); + } + + void SetSamplerBorderColor( + uint32 id, + float red, float green, float blue, float alpha) { + cmd::SetSamplerBorderColor& cmd = + GetCmdSpace<cmd::SetSamplerBorderColor>(); + cmd.Init(id, red, green, blue, alpha); + } + + void SetSamplerTexture(uint32 id, uint32 texture_id) { + cmd::SetSamplerTexture& cmd = GetCmdSpace<cmd::SetSamplerTexture>(); + cmd.Init(id, texture_id); + } + + void SetScissor( + uint32 x, + uint32 y, + uint32 width, + uint32 height, + bool enable) { + cmd::SetScissor& cmd = GetCmdSpace<cmd::SetScissor>(); + cmd.Init( + x, + y, + width, + height, + enable); + } + + void SetPolygonOffset(float slope_factor, float units) { + cmd::SetPolygonOffset& cmd = GetCmdSpace<cmd::SetPolygonOffset>(); + cmd.Init(slope_factor, units); + } + + void SetPointLineRaster( + bool line_smooth_enable, bool point_sprite_enable, float point_size) { + cmd::SetPointLineRaster& cmd = GetCmdSpace<cmd::SetPointLineRaster>(); + cmd.Init(line_smooth_enable, point_sprite_enable, point_size); + } + + void SetPolygonRaster(uint32 fill_mode, uint32 cull_mode) { + cmd::SetPolygonRaster& cmd = GetCmdSpace<cmd::SetPolygonRaster>(); + cmd.Init(fill_mode, cull_mode); + } + + void SetAlphaTest(uint32 func, bool enable, float value) { + cmd::SetAlphaTest& cmd = GetCmdSpace<cmd::SetAlphaTest>(); + cmd.Init(func, enable, value); + } + + void SetDepthTest(uint32 func, bool write_enable, bool enable) { + cmd::SetDepthTest& cmd = GetCmdSpace<cmd::SetDepthTest>(); + cmd.Init(func, write_enable, enable); + } + + void SetStencilTest( + uint8 write_mask, + uint8 compare_mask, + uint8 reference_value, + bool separate_ccw, + bool enable, + uint8 cw_func, + uint8 cw_pass_op, + uint8 cw_fail_op, + uint8 cw_z_fail_op, + uint8 ccw_func, + uint8 ccw_pass_op, + uint8 ccw_fail_op, + uint8 ccw_z_fail_op) { + cmd::SetStencilTest& cmd = GetCmdSpace<cmd::SetStencilTest>(); + cmd.Init( + write_mask, + compare_mask, + reference_value, + separate_ccw, + enable, + cw_func, + cw_pass_op, + cw_fail_op, + cw_z_fail_op, + ccw_func, + ccw_pass_op, + ccw_fail_op, + ccw_z_fail_op); + } + + void SetColorWrite(uint8 mask, bool dither_enable) { + cmd::SetColorWrite& cmd = GetCmdSpace<cmd::SetColorWrite>(); + cmd.Init(mask, dither_enable); + } + + void SetBlending( + uint8 color_src_func, + uint8 color_dst_func, + uint8 color_eq, + uint8 alpha_src_func, + uint8 alpha_dst_func, + uint8 alpha_eq, + bool separate_alpha, + bool enable) { + cmd::SetBlending& cmd = GetCmdSpace<cmd::SetBlending>(); + cmd.Init( + color_src_func, + color_dst_func, + color_eq, + alpha_src_func, + alpha_dst_func, + alpha_eq, + separate_alpha, + enable); + } + + void SetBlendingColor(float red, float green, float blue, float alpha) { + cmd::SetBlendingColor& cmd = GetCmdSpace<cmd::SetBlendingColor>(); + cmd.Init(red, green, blue, alpha); + } + + void CreateRenderSurface( + uint32 id, uint32 texture_id, + uint32 width, uint32 height, + uint32 level, uint32 side) { + cmd::CreateRenderSurface& cmd = GetCmdSpace<cmd::CreateRenderSurface>(); + cmd.Init(id, texture_id, width, height, level, side); + } + + void DestroyRenderSurface(uint32 id) { + cmd::DestroyRenderSurface& cmd = + GetCmdSpace<cmd::DestroyRenderSurface>(); + cmd.Init(id); + } + + void CreateDepthSurface(uint32 id, uint32 width, uint32 height) { + cmd::CreateDepthSurface& cmd = GetCmdSpace<cmd::CreateDepthSurface>(); + cmd.Init(id, width, height); + } + + void DestroyDepthSurface(uint32 id) { + cmd::DestroyDepthSurface& cmd = GetCmdSpace<cmd::DestroyDepthSurface>(); + cmd.Init(id); + } + + void SetRenderSurface(uint32 render_surface_id, uint32 depth_surface_id) { + cmd::SetRenderSurface& cmd = GetCmdSpace<cmd::SetRenderSurface>(); + cmd.Init(render_surface_id, depth_surface_id); + } + + void SetBackSurfaces() { + cmd::SetBackSurfaces& cmd = GetCmdSpace<cmd::SetBackSurfaces>(); + cmd.Init(); + } + private: // Waits until get changes, updating the value of get_. void WaitForGetChange(); // Returns the number of available entries (they may not be contiguous). unsigned int AvailableEntries() { - return (get_ - put_ - 1 + entry_count_) % entry_count_; + return static_cast<unsigned int>( + (get_ - put_ - 1 + entry_count_) % entry_count_); } BufferSyncInterface *interface_; diff --git a/o3d/command_buffer/client/cross/cmd_buffer_helper_test.cc b/o3d/command_buffer/client/cross/cmd_buffer_helper_test.cc index e25bcd9..8bb4104 100644 --- a/o3d/command_buffer/client/cross/cmd_buffer_helper_test.cc +++ b/o3d/command_buffer/client/cross/cmd_buffer_helper_test.cc @@ -58,7 +58,7 @@ class CommandBufferHelperTest : public testing::Test { // ignore noops in the mock - we don't want to inspect the internals of the // helper. EXPECT_CALL(*api_mock_, DoCommand(0, 0, _)) - .WillRepeatedly(Return(BufferSyncInterface::PARSE_NO_ERROR)); + .WillRepeatedly(Return(BufferSyncInterface::kParseNoError)); engine_.reset(new CommandBufferEngine(api_mock_.get())); api_mock_->set_engine(engine_.get()); @@ -126,22 +126,22 @@ TEST_F(CommandBufferHelperTest, TestCommandProcessing) { // helper. EXPECT_TRUE(engine()->rpc_impl() != NULL); EXPECT_TRUE(engine()->parser() != NULL); - EXPECT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + EXPECT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); EXPECT_EQ(0, engine()->Get()); // Add 3 commands through the helper - AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 1, 0, NULL); + AddCommandWithExpect(BufferSyncInterface::kParseNoError, 1, 0, NULL); CommandBufferEntry args1[2]; args1[0].value_uint32 = 3; args1[1].value_float = 4.f; - AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 2, 2, args1); + AddCommandWithExpect(BufferSyncInterface::kParseNoError, 2, 2, args1); CommandBufferEntry args2[2]; args2[0].value_uint32 = 5; args2[1].value_float = 6.f; - AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 3, 2, args2); + AddCommandWithExpect(BufferSyncInterface::kParseNoError, 3, 2, args2); helper()->Flush(); // Check that the engine has work to do now. @@ -156,8 +156,8 @@ TEST_F(CommandBufferHelperTest, TestCommandProcessing) { Mock::VerifyAndClearExpectations(api_mock()); // Check the error status. - ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); } // Checks that commands in the buffer are properly executed when wrapping the @@ -169,7 +169,7 @@ TEST_F(CommandBufferHelperTest, TestCommandWrapping) { args1[1].value_float = 4.f; for (unsigned int i = 0; i < 5; ++i) { - AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, i+1, 2, args1); + AddCommandWithExpect(BufferSyncInterface::kParseNoError, i+1, 2, args1); } helper()->Finish(); @@ -177,8 +177,8 @@ TEST_F(CommandBufferHelperTest, TestCommandWrapping) { Mock::VerifyAndClearExpectations(api_mock()); // Check the error status. - ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); } @@ -191,9 +191,9 @@ TEST_F(CommandBufferHelperTest, TestRecoverableError) { args[1].value_float = 4.f; // Create a command buffer with 3 commands, 2 of them generating errors - AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 1, 2, args); - AddCommandWithExpect(BufferSyncInterface::PARSE_UNKNOWN_COMMAND, 2, 2, args); - AddCommandWithExpect(BufferSyncInterface::PARSE_INVALID_ARGUMENTS, 3, 2, + AddCommandWithExpect(BufferSyncInterface::kParseNoError, 1, 2, args); + AddCommandWithExpect(BufferSyncInterface::kParseUnknownCommand, 2, 2, args); + AddCommandWithExpect(BufferSyncInterface::kParseInvalidArguments, 3, 2, args); helper()->Finish(); @@ -201,10 +201,10 @@ TEST_F(CommandBufferHelperTest, TestRecoverableError) { Mock::VerifyAndClearExpectations(api_mock()); // Check that the error status was set to the first error. - EXPECT_EQ(BufferSyncInterface::PARSE_UNKNOWN_COMMAND, + EXPECT_EQ(BufferSyncInterface::kParseUnknownCommand, engine()->GetParseError()); // Check that the error status was reset after the query. - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); engine()->CloseConnection(); } @@ -217,10 +217,10 @@ TEST_F(CommandBufferHelperTest, TestAvailableEntries) { args[1].value_float = 4.f; // Add 2 commands through the helper - 8 entries - AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 1, 0, NULL); - AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 2, 0, NULL); - AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 3, 2, args); - AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 4, 2, args); + AddCommandWithExpect(BufferSyncInterface::kParseNoError, 1, 0, NULL); + AddCommandWithExpect(BufferSyncInterface::kParseNoError, 2, 0, NULL); + AddCommandWithExpect(BufferSyncInterface::kParseNoError, 3, 2, args); + AddCommandWithExpect(BufferSyncInterface::kParseNoError, 4, 2, args); // Ask for 5 entries. helper()->WaitForAvailableEntries(5); @@ -229,7 +229,7 @@ TEST_F(CommandBufferHelperTest, TestAvailableEntries) { CheckFreeSpace(put, 5); // Add more commands. - AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 5, 2, args); + AddCommandWithExpect(BufferSyncInterface::kParseNoError, 5, 2, args); // Wait until everything is done done. helper()->Finish(); @@ -238,8 +238,8 @@ TEST_F(CommandBufferHelperTest, TestAvailableEntries) { Mock::VerifyAndClearExpectations(api_mock()); // Check the error status. - ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); } // Checks that the InsertToken/WaitForToken work. @@ -249,16 +249,16 @@ TEST_F(CommandBufferHelperTest, TestToken) { args[1].value_float = 4.f; // Add a first command. - AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 3, 2, args); + AddCommandWithExpect(BufferSyncInterface::kParseNoError, 3, 2, args); // keep track of the buffer position. CommandBufferOffset command1_put = get_helper_put(); unsigned int token = helper()->InsertToken(); - EXPECT_CALL(*api_mock(), DoCommand(SET_TOKEN, 1, _)) + EXPECT_CALL(*api_mock(), DoCommand(kSetToken, 1, _)) .WillOnce(DoAll(Invoke(api_mock(), &AsyncAPIMock::SetToken), - Return(BufferSyncInterface::PARSE_NO_ERROR))); + Return(BufferSyncInterface::kParseNoError))); // Add another command. - AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 4, 2, args); + AddCommandWithExpect(BufferSyncInterface::kParseNoError, 4, 2, args); helper()->WaitForToken(token); // check that the get pointer is beyond the first command. EXPECT_LE(command1_put, engine()->Get()); @@ -268,8 +268,8 @@ TEST_F(CommandBufferHelperTest, TestToken) { Mock::VerifyAndClearExpectations(api_mock()); // Check the error status. - ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); } } // namespace command_buffer diff --git a/o3d/command_buffer/client/cross/effect_helper.cc b/o3d/command_buffer/client/cross/effect_helper.cc index ced1b3b..b9254cc 100644 --- a/o3d/command_buffer/client/cross/effect_helper.cc +++ b/o3d/command_buffer/client/cross/effect_helper.cc @@ -52,18 +52,14 @@ bool EffectHelper::CreateEffectParameters(ResourceID effect_id, // Get the param count. Uint32 *retval = shm_allocator_->AllocTyped<Uint32>(1); - CommandBufferEntry args[4]; - args[0].value_uint32 = effect_id; - args[1].value_uint32 = sizeof(*retval); - args[2].value_uint32 = shm_id_; - args[3].value_uint32 = shm_allocator_->GetOffset(retval); - helper_->AddCommand(GET_PARAM_COUNT, 4, args); + helper_->GetParamCount(effect_id, sizeof(*retval), + shm_id_, shm_allocator_->GetOffset(retval)); // Finish has to be called to get the result. helper_->Finish(); // We could have failed if the effect_id is invalid. if (helper_->interface()->GetParseError() != - BufferSyncInterface::PARSE_NO_ERROR) { + BufferSyncInterface::kParseNoError) { shm_allocator_->Free(retval); return false; } @@ -79,10 +75,7 @@ bool EffectHelper::CreateEffectParameters(ResourceID effect_id, for (unsigned int i = 0; i < param_count; ++i) { EffectParamDesc *desc = &((*descs)[i]); desc->id = param_id_allocator_->AllocateID(); - args[0].value_uint32 = desc->id; - args[1].value_uint32 = effect_id; - args[2].value_uint32 = i; - helper_->AddCommand(CREATE_PARAM, 3, args); + helper_->CreateParam(desc->id, effect_id, i); } // Read param descriptions in batches. We use as much shared memory as @@ -97,16 +90,14 @@ bool EffectHelper::CreateEffectParameters(ResourceID effect_id, for (unsigned int j = 0 ; j < count; ++j) { EffectParamDesc *desc = &((*descs)[i + j]); Desc *raw_desc = raw_descs + j; - args[0].value_uint32 = desc->id; - args[1].value_uint32 = sizeof(*raw_desc); - args[2].value_uint32 = shm_id_; - args[3].value_uint32 = shm_allocator_->GetOffset(raw_desc); - helper_->AddCommand(GET_PARAM_DESC, 4, args); + helper_->GetParamDesc(desc->id, sizeof(*raw_desc), + shm_id_, + shm_allocator_->GetOffset(raw_desc)); } // Finish to get the results. helper_->Finish(); DCHECK_EQ(helper_->interface()->GetParseError(), - BufferSyncInterface::PARSE_NO_ERROR); + BufferSyncInterface::kParseNoError); for (unsigned int j = 0 ; j < count; ++j) { EffectParamDesc *desc = &((*descs)[i + j]); Desc *raw_desc = raw_descs + j; @@ -133,18 +124,16 @@ bool EffectHelper::GetParamStrings(EffectParamDesc *desc) { // Not enough memory to get the param desc. return false; } - CommandBufferEntry args[4]; - args[0].value_uint32 = desc->id; - args[1].value_uint32 = size; - args[2].value_uint32 = shm_id_; - args[3].value_uint32 = shm_allocator_->GetOffset(raw_desc); - helper_->AddCommand(GET_PARAM_DESC, 4, args); + helper_->GetParamDesc(desc->id, size, + shm_id_, + shm_allocator_->GetOffset(raw_desc)); + // Finish to get the results. helper_->Finish(); // We could have failed if the param ID is invalid. if (helper_->interface()->GetParseError() != - BufferSyncInterface::PARSE_NO_ERROR) { + BufferSyncInterface::kParseNoError) { shm_allocator_->Free(raw_desc); return false; } @@ -162,13 +151,13 @@ bool EffectHelper::GetParamStrings(EffectParamDesc *desc) { // Not enough memory to get the param desc. return false; } - args[1].value_uint32 = size; - args[3].value_uint32 = shm_allocator_->GetOffset(raw_desc); - helper_->AddCommand(GET_PARAM_DESC, 4, args); + helper_->GetParamDesc(desc->id, size, + shm_id_, + shm_allocator_->GetOffset(raw_desc)); // Finish to get the results. helper_->Finish(); DCHECK_EQ(helper_->interface()->GetParseError(), - BufferSyncInterface::PARSE_NO_ERROR); + BufferSyncInterface::kParseNoError); DCHECK_EQ(raw_desc->size, size); } @@ -201,11 +190,9 @@ bool EffectHelper::GetParamStrings(EffectParamDesc *desc) { void EffectHelper::DestroyEffectParameters( const std::vector<EffectParamDesc> &descs) { - CommandBufferEntry args[1]; for (unsigned int i = 0; i < descs.size(); ++i) { const EffectParamDesc &desc = descs[i]; - args[0].value_uint32 = desc.id; - helper_->AddCommand(DESTROY_PARAM, 1, args); + helper_->DestroyParam(desc.id); param_id_allocator_->FreeID(desc.id); } } @@ -217,18 +204,15 @@ bool EffectHelper::GetEffectStreams(ResourceID effect_id, // Get the param count. Uint32 *retval = shm_allocator_->AllocTyped<Uint32>(1); - CommandBufferEntry args[5]; - args[0].value_uint32 = effect_id; - args[1].value_uint32 = sizeof(*retval); - args[2].value_uint32 = shm_id_; - args[3].value_uint32 = shm_allocator_->GetOffset(retval); - helper_->AddCommand(GET_STREAM_COUNT, 4, args); + helper_->GetStreamCount(effect_id, sizeof(*retval), + shm_id_, + shm_allocator_->GetOffset(retval)); // Finish has to be called to get the result. helper_->Finish(); // We could have failed if the effect_id is invalid. if (helper_->interface()->GetParseError() != - BufferSyncInterface::PARSE_NO_ERROR) { + BufferSyncInterface::kParseNoError) { shm_allocator_->Free(retval); return false; } @@ -253,17 +237,14 @@ bool EffectHelper::GetEffectStreams(ResourceID effect_id, for (unsigned int j = 0 ; j < count; ++j) { EffectStreamDesc *desc = &((*descs)[i + j]); Desc *raw_desc = raw_descs + j; - args[0].value_uint32 = effect_id; - args[1].value_uint32 = i+j; - args[2].value_uint32 = sizeof(*raw_desc); - args[3].value_uint32 = shm_id_; - args[4].value_uint32 = shm_allocator_->GetOffset(raw_desc); - helper_->AddCommand(GET_STREAM_DESC, 5, args); + helper_->GetStreamDesc(effect_id, i + j, sizeof(*raw_desc), + shm_id_, + shm_allocator_->GetOffset(raw_desc)); } // Finish to get the results. helper_->Finish(); DCHECK_EQ(helper_->interface()->GetParseError(), - BufferSyncInterface::PARSE_NO_ERROR); + BufferSyncInterface::kParseNoError); for (unsigned int j = 0 ; j < count; ++j) { EffectStreamDesc *desc = &((*descs)[i + j]); Desc *raw_desc = raw_descs + j; diff --git a/o3d/command_buffer/client/cross/fenced_allocator_test.cc b/o3d/command_buffer/client/cross/fenced_allocator_test.cc index 93dedca..9d63cc0 100644 --- a/o3d/command_buffer/client/cross/fenced_allocator_test.cc +++ b/o3d/command_buffer/client/cross/fenced_allocator_test.cc @@ -50,8 +50,8 @@ using testing::_; // Test fixture for FencedAllocator test - Creates a FencedAllocator, using a // CommandBufferHelper with a mock AsyncAPIInterface for its interface (calling -// it directly, not through the RPC mechanism), making sure NOOPs are ignored -// and SET_TOKEN are properly forwarded to the engine. +// it directly, not through the RPC mechanism), making sure Noops are ignored +// and SetToken are properly forwarded to the engine. class FencedAllocatorTest : public testing::Test { public: static const unsigned int kBufferSize = 1024; @@ -61,12 +61,12 @@ class FencedAllocatorTest : public testing::Test { api_mock_.reset(new AsyncAPIMock); // ignore noops in the mock - we don't want to inspect the internals of the // helper. - EXPECT_CALL(*api_mock_, DoCommand(NOOP, 0, _)) - .WillRepeatedly(Return(BufferSyncInterface::PARSE_NO_ERROR)); + EXPECT_CALL(*api_mock_, DoCommand(kNoop, 0, _)) + .WillRepeatedly(Return(BufferSyncInterface::kParseNoError)); // Forward the SetToken calls to the engine - EXPECT_CALL(*api_mock(), DoCommand(SET_TOKEN, 1, _)) + EXPECT_CALL(*api_mock(), DoCommand(kSetToken, 1, _)) .WillRepeatedly(DoAll(Invoke(api_mock(), &AsyncAPIMock::SetToken), - Return(BufferSyncInterface::PARSE_NO_ERROR))); + Return(BufferSyncInterface::kParseNoError))); engine_.reset(new CommandBufferEngine(api_mock_.get())); api_mock_->set_engine(engine_.get()); @@ -312,7 +312,7 @@ TEST_F(FencedAllocatorTest, TestGetLargestFreeOrPendingSize) { // Test fixture for FencedAllocatorWrapper test - Creates a // FencedAllocatorWrapper, using a CommandBufferHelper with a mock // AsyncAPIInterface for its interface (calling it directly, not through the -// RPC mechanism), making sure NOOPs are ignored and SET_TOKEN are properly +// RPC mechanism), making sure Noops are ignored and SetToken are properly // forwarded to the engine. class FencedAllocatorWrapperTest : public testing::Test { public: @@ -323,12 +323,12 @@ class FencedAllocatorWrapperTest : public testing::Test { api_mock_.reset(new AsyncAPIMock); // ignore noops in the mock - we don't want to inspect the internals of the // helper. - EXPECT_CALL(*api_mock_, DoCommand(NOOP, 0, _)) - .WillRepeatedly(Return(BufferSyncInterface::PARSE_NO_ERROR)); + EXPECT_CALL(*api_mock_, DoCommand(kNoop, 0, _)) + .WillRepeatedly(Return(BufferSyncInterface::kParseNoError)); // Forward the SetToken calls to the engine - EXPECT_CALL(*api_mock(), DoCommand(SET_TOKEN, 1, _)) + EXPECT_CALL(*api_mock(), DoCommand(kSetToken, 1, _)) .WillRepeatedly(DoAll(Invoke(api_mock(), &AsyncAPIMock::SetToken), - Return(BufferSyncInterface::PARSE_NO_ERROR))); + Return(BufferSyncInterface::kParseNoError))); engine_.reset(new CommandBufferEngine(api_mock_.get())); api_mock_->set_engine(engine_.get()); diff --git a/o3d/command_buffer/common/cross/buffer_sync_api.h b/o3d/command_buffer/common/cross/buffer_sync_api.h index 62d6011..e216e7a 100644 --- a/o3d/command_buffer/common/cross/buffer_sync_api.h +++ b/o3d/command_buffer/common/cross/buffer_sync_api.h @@ -49,21 +49,21 @@ typedef size_t CommandBufferOffset; class BufferSyncInterface { public: // Status of the command buffer service. It does not process commands - // (meaning: get will not change) unless in PARSING state. + // (meaning: get will not change) unless in kParsing state. enum ParserStatus { - NOT_CONNECTED, // The service is not connected - initial state. - NO_BUFFER, // The service is connected but no buffer was set. - PARSING, // The service is connected, and parsing commands from the + kNotConnected, // The service is not connected - initial state. + kNoBuffer, // The service is connected but no buffer was set. + kParsing, // The service is connected, and parsing commands from the // buffer. - PARSE_ERROR, // Parsing stopped because a parse error was found. + kParseError, // Parsing stopped because a parse error was found. }; enum ParseError { - PARSE_NO_ERROR, - PARSE_INVALID_SIZE, - PARSE_OUT_OF_BOUNDS, - PARSE_UNKNOWN_COMMAND, - PARSE_INVALID_ARGUMENTS, + kParseNoError, + kParseInvalidSize, + kParseOutOfBounds, + kParseUnknownCommand, + kParseInvalidArguments, }; // Invalid shared memory Id, returned by RegisterSharedMemory in case of @@ -155,8 +155,8 @@ class BufferSyncInterface { // Gets the current parse error. The current parse error is set when the // service is in the PARSE_ERROR status. It may also be set while in the - // PARSING state, if a recoverable error (like PARSE_UNKNOWN_METHOD) was - // encountered. Getting the error resets it to PARSE_NO_ERROR. + // kParsing state, if a recoverable error (like PARSE_UNKNOWN_METHOD) was + // encountered. Getting the error resets it to kParseNoError. // Returns: // The current parse error. virtual ParseError GetParseError() = 0; diff --git a/o3d/command_buffer/common/cross/cmd_buffer_format.h b/o3d/command_buffer/common/cross/cmd_buffer_format.h index 51d0e9b..63bcc8be 100644 --- a/o3d/command_buffer/common/cross/cmd_buffer_format.h +++ b/o3d/command_buffer/common/cross/cmd_buffer_format.h @@ -30,7 +30,31 @@ */ -// This file contains the binary format definition of the command buffer. +// This file contains the binary format definition of the command buffer and +// command buffer commands. +// It is recommended you use the CommandBufferHelper object to create commands +// but if you want to go lower level you can use the structures here to help. +// +// A few ways to use them: +// +// Fill out a structure in place: +// +// cmd::SetViewport::Set(ptrToSomeSharedMemory, +// left, right, width, height, z_min, z_max); +// +// Fill out consecutive commands: +// +// Note that each cmd::XXX::Set function returns a pointer to the place +// the next command should go. +// +// void* dest = ptrToSomeSharedMemory; +// dest = cmd::SetViewport::Set(dest, left, right, width, height, min, max); +// dest = cmd::Clear::Set(dest, buffers, r, g, b, a, depth, stencil); +// dest = cmd::Draw::Set(dest, primitive_type, first, count); +// +// NOTE: The types in this file must be POD types. That means they can not have +// constructors, destructors, virtual functions or inheritance and they can only +// use other POD types or intrinsics as members. #ifndef O3D_COMMAND_BUFFER_COMMON_CROSS_CMD_BUFFER_FORMAT_H_ #define O3D_COMMAND_BUFFER_COMMON_CROSS_CMD_BUFFER_FORMAT_H_ @@ -43,11 +67,44 @@ namespace o3d { namespace command_buffer { +// Computes the number of command buffer entries needed for a certain size. In +// other words it rounds up to a multiple of entries. +inline uint32 ComputeNumEntries(size_t size_in_bytes) { + return static_cast<uint32>( + (size_in_bytes + sizeof(uint32) - 1) / sizeof(uint32)); // NOLINT +} + +// Rounds up to a multiple of entries in bytes. +inline size_t RoundSizeToMultipleOfEntries(size_t size_in_bytes) { + return ComputeNumEntries(size_in_bytes) * sizeof(uint32); // NOLINT +} + // Struct that defines the command header in the command buffer. struct CommandHeader { Uint32 size:8; Uint32 command:24; + + void Init(uint32 _command, uint32 _size) { + command = _command; + size = _size; + } + + // Sets the header based on the passed in command. Can not be used for + // variable sized commands like immediate commands or Noop. + template <typename T> + void SetCmd() { + COMPILE_ASSERT(T::kArgFlags == cmd::kFixed, Cmd_kArgFlags_not_kFixed); + Init(T::kCmdId, ComputeNumEntries(sizeof(T))); // NOLINT + } + + // Sets the header by a size in bytes. + template <typename T> + void SetCmdBySize(uint32 size_in_bytes) { + COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); + Init(T::kCmdId, ComputeNumEntries(sizeof(T) + size_in_bytes)); // NOLINT + } }; + COMPILE_ASSERT(sizeof(CommandHeader) == 4, Sizeof_CommandHeader_is_not_4); // Union that defines possible command buffer entries. @@ -61,16 +118,17 @@ union CommandBufferEntry { COMPILE_ASSERT(sizeof(CommandBufferEntry) == 4, Sizeof_CommandBufferEntry_is_not_4); -// Bitfields for the SET_VERTEX_INPUT command. +// Bitfields for the SetVertexInput command. namespace set_vertex_input_cmd { // argument 4 -typedef BitField<0, 4> SemanticIndex; +typedef BitField<0, 4> SemanticIndex; // TODO(gman): shouldn't this be bigger + // than 4 bits for future expansion? typedef BitField<4, 4> Semantic; typedef BitField<8, 8> Type; typedef BitField<16, 16> Stride; } // namespace set_vertex_input_cmd -// Bitfields for the CREATE_TEXTURE_2D command. +// Bitfields for the CreateTexture2d command. namespace create_texture_2d_cmd { // argument 1 typedef BitField<0, 16> Width; @@ -82,7 +140,7 @@ typedef BitField<8, 8> Format; typedef BitField<16, 16> Flags; } // namespace create_texture_2d_cmd -// Bitfields for the CREATE_TEXTURE_3D command. +// Bitfields for the CreateTexture3d command. namespace create_texture_3d_cmd { // argument 1 typedef BitField<0, 16> Width; @@ -97,7 +155,7 @@ typedef BitField<8, 8> Format; typedef BitField<16, 16> Flags; } // namespace create_texture_3d_cmd -// Bitfields for the CREATE_TEXTURE_CUBE command. +// Bitfields for the CreateTextureCube command. namespace create_texture_cube_cmd { // argument 1 typedef BitField<0, 16> Side; @@ -109,7 +167,7 @@ typedef BitField<8, 8> Format; typedef BitField<16, 16> Flags; } // namespace create_texture_cube_cmd -// Bitfields for the CREATE_RENDER_SURFACE command. +// Bitfields for the CreateRenderSurface command. namespace create_render_surface_cmd { // argument 1 typedef BitField<0, 16> Width; @@ -119,7 +177,14 @@ typedef BitField<0, 16> Levels; typedef BitField<16, 16> Side; } // namespace create_render_surface_cmd -// Bitfields for the SET_TEXTURE_DATA command. +// Bitfields for the CreateDepthSurface command. +namespace create_depth_surface_cmd { +// argument 1 +typedef BitField<0, 16> Width; +typedef BitField<16, 16> Height; +} // namespace create_depth_surface_cmd + +// Bitfields for the SetTextureData command. namespace set_texture_data_cmd { // argument 1 typedef BitField<0, 16> X; @@ -136,7 +201,7 @@ typedef BitField<4, 3> Face; typedef BitField<7, 25> Unused; } // namespace set_texture_data_cmd -// Bitfields for the SET_TEXTURE_DATA_IMMEDIATE command. +// Bitfields for the SetTextureDataImmediate command. namespace set_texture_data_immediate_cmd { // argument 1 typedef BitField<0, 16> X; @@ -153,7 +218,7 @@ typedef BitField<4, 3> Face; typedef BitField<7, 25> Unused; } // namespace set_texture_data_immediate_cmd -// Bitfields for the GET_TEXTURE_DATA command. +// Bitfields for the GetTextureData command. namespace get_texture_data_cmd { // argument 1 typedef BitField<0, 16> X; @@ -170,7 +235,7 @@ typedef BitField<4, 3> Face; typedef BitField<7, 25> Unused; } // namespace get_texture_data_cmd -// Bitfields for the SET_SAMPLER_STATES command. +// Bitfields for the SetSamplerStates command. namespace set_sampler_states { // argument 2 typedef BitField<0, 3> AddressingU; @@ -278,75 +343,75 @@ typedef BitField<31, 1> Enable; // // NOTE: THE ORDER OF THESE MUST NOT CHANGE (their id is derived by order) #define O3D_COMMAND_BUFFER_CMDS \ - O3D_COMMAND_BUFFER_CMD_OP(NOOP) /* 0 */ \ - O3D_COMMAND_BUFFER_CMD_OP(SET_TOKEN) \ - O3D_COMMAND_BUFFER_CMD_OP(BEGIN_FRAME) \ - O3D_COMMAND_BUFFER_CMD_OP(END_FRAME) \ - O3D_COMMAND_BUFFER_CMD_OP(CLEAR) \ - O3D_COMMAND_BUFFER_CMD_OP(CREATE_VERTEX_BUFFER) \ - O3D_COMMAND_BUFFER_CMD_OP(DESTROY_VERTEX_BUFFER) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_VERTEX_BUFFER_DATA) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_VERTEX_BUFFER_DATA_IMMEDIATE) \ - O3D_COMMAND_BUFFER_CMD_OP(GET_VERTEX_BUFFER_DATA) \ - O3D_COMMAND_BUFFER_CMD_OP(CREATE_INDEX_BUFFER) /* 10 */ \ - O3D_COMMAND_BUFFER_CMD_OP(DESTROY_INDEX_BUFFER) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_INDEX_BUFFER_DATA) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_INDEX_BUFFER_DATA_IMMEDIATE) \ - O3D_COMMAND_BUFFER_CMD_OP(GET_INDEX_BUFFER_DATA) \ - O3D_COMMAND_BUFFER_CMD_OP(CREATE_VERTEX_STRUCT) \ - O3D_COMMAND_BUFFER_CMD_OP(DESTROY_VERTEX_STRUCT) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_VERTEX_INPUT) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_VERTEX_STRUCT) \ - O3D_COMMAND_BUFFER_CMD_OP(DRAW) \ - O3D_COMMAND_BUFFER_CMD_OP(DRAW_INDEXED) /* 20 */ \ - O3D_COMMAND_BUFFER_CMD_OP(CREATE_EFFECT) \ - O3D_COMMAND_BUFFER_CMD_OP(CREATE_EFFECT_IMMEDIATE) \ - O3D_COMMAND_BUFFER_CMD_OP(DESTROY_EFFECT) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_EFFECT) \ - O3D_COMMAND_BUFFER_CMD_OP(GET_PARAM_COUNT) \ - O3D_COMMAND_BUFFER_CMD_OP(CREATE_PARAM) \ - O3D_COMMAND_BUFFER_CMD_OP(CREATE_PARAM_BY_NAME) \ - O3D_COMMAND_BUFFER_CMD_OP(CREATE_PARAM_BY_NAME_IMMEDIATE) \ - O3D_COMMAND_BUFFER_CMD_OP(DESTROY_PARAM) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_PARAM_DATA) /* 30 */ \ - O3D_COMMAND_BUFFER_CMD_OP(SET_PARAM_DATA_IMMEDIATE) \ - O3D_COMMAND_BUFFER_CMD_OP(GET_PARAM_DESC) \ - O3D_COMMAND_BUFFER_CMD_OP(GET_STREAM_COUNT) \ - O3D_COMMAND_BUFFER_CMD_OP(GET_STREAM_DESC) \ - O3D_COMMAND_BUFFER_CMD_OP(DESTROY_TEXTURE) \ - O3D_COMMAND_BUFFER_CMD_OP(CREATE_TEXTURE_2D) \ - O3D_COMMAND_BUFFER_CMD_OP(CREATE_TEXTURE_3D) \ - O3D_COMMAND_BUFFER_CMD_OP(CREATE_TEXTURE_CUBE) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_TEXTURE_DATA) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_TEXTURE_DATA_IMMEDIATE) /* 40 */ \ - O3D_COMMAND_BUFFER_CMD_OP(GET_TEXTURE_DATA) \ - O3D_COMMAND_BUFFER_CMD_OP(CREATE_SAMPLER) \ - O3D_COMMAND_BUFFER_CMD_OP(DESTROY_SAMPLER) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_SAMPLER_STATES) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_SAMPLER_BORDER_COLOR) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_SAMPLER_TEXTURE) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_VIEWPORT) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_SCISSOR) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_POINT_LINE_RASTER) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_POLYGON_RASTER) /* 50 */ \ - O3D_COMMAND_BUFFER_CMD_OP(SET_POLYGON_OFFSET) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_ALPHA_TEST) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_DEPTH_TEST) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_STENCIL_TEST) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_BLENDING) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_BLENDING_COLOR) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_COLOR_WRITE) \ - O3D_COMMAND_BUFFER_CMD_OP(CREATE_RENDER_SURFACE) \ - O3D_COMMAND_BUFFER_CMD_OP(DESTROY_RENDER_SURFACE) \ - O3D_COMMAND_BUFFER_CMD_OP(CREATE_DEPTH_SURFACE) /* 60 */ \ - O3D_COMMAND_BUFFER_CMD_OP(DESTROY_DEPTH_SURFACE) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_RENDER_SURFACE) \ - O3D_COMMAND_BUFFER_CMD_OP(SET_BACK_SURFACES) \ + O3D_COMMAND_BUFFER_CMD_OP(Noop) /* 0 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetToken) /* 1 */ \ + O3D_COMMAND_BUFFER_CMD_OP(BeginFrame) /* 2 */ \ + O3D_COMMAND_BUFFER_CMD_OP(EndFrame) /* 3 */ \ + O3D_COMMAND_BUFFER_CMD_OP(Clear) /* 4 */ \ + O3D_COMMAND_BUFFER_CMD_OP(CreateVertexBuffer) /* 5 */ \ + O3D_COMMAND_BUFFER_CMD_OP(DestroyVertexBuffer) /* 6 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetVertexBufferData) /* 7 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetVertexBufferDataImmediate) /* 8 */ \ + O3D_COMMAND_BUFFER_CMD_OP(GetVertexBufferData) /* 9 */ \ + O3D_COMMAND_BUFFER_CMD_OP(CreateIndexBuffer) /* 10 */ \ + O3D_COMMAND_BUFFER_CMD_OP(DestroyIndexBuffer) /* 11 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetIndexBufferData) /* 12 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetIndexBufferDataImmediate) /* 13 */ \ + O3D_COMMAND_BUFFER_CMD_OP(GetIndexBufferData) /* 14 */ \ + O3D_COMMAND_BUFFER_CMD_OP(CreateVertexStruct) /* 15 */ \ + O3D_COMMAND_BUFFER_CMD_OP(DestroyVertexStruct) /* 16 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetVertexInput) /* 17 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetVertexStruct) /* 18 */ \ + O3D_COMMAND_BUFFER_CMD_OP(Draw) /* 19 */ \ + O3D_COMMAND_BUFFER_CMD_OP(DrawIndexed) /* 20 */ \ + O3D_COMMAND_BUFFER_CMD_OP(CreateEffect) /* 21 */ \ + O3D_COMMAND_BUFFER_CMD_OP(CreateEffectImmediate) /* 22 */ \ + O3D_COMMAND_BUFFER_CMD_OP(DestroyEffect) /* 23 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetEffect) /* 24 */ \ + O3D_COMMAND_BUFFER_CMD_OP(GetParamCount) /* 25 */ \ + O3D_COMMAND_BUFFER_CMD_OP(CreateParam) /* 26 */ \ + O3D_COMMAND_BUFFER_CMD_OP(CreateParamByName) /* 27 */ \ + O3D_COMMAND_BUFFER_CMD_OP(CreateParamByNameImmediate) /* 28 */ \ + O3D_COMMAND_BUFFER_CMD_OP(DestroyParam) /* 29 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetParamData) /* 30 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetParamDataImmediate) /* 31 */ \ + O3D_COMMAND_BUFFER_CMD_OP(GetParamDesc) /* 32 */ \ + O3D_COMMAND_BUFFER_CMD_OP(GetStreamCount) /* 33 */ \ + O3D_COMMAND_BUFFER_CMD_OP(GetStreamDesc) /* 34 */ \ + O3D_COMMAND_BUFFER_CMD_OP(DestroyTexture) /* 35 */ \ + O3D_COMMAND_BUFFER_CMD_OP(CreateTexture2d) /* 36 */ \ + O3D_COMMAND_BUFFER_CMD_OP(CreateTexture3d) /* 37 */ \ + O3D_COMMAND_BUFFER_CMD_OP(CreateTextureCube) /* 38 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetTextureData) /* 39 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetTextureDataImmediate) /* 40 */ \ + O3D_COMMAND_BUFFER_CMD_OP(GetTextureData) /* 41 */ \ + O3D_COMMAND_BUFFER_CMD_OP(CreateSampler) /* 42 */ \ + O3D_COMMAND_BUFFER_CMD_OP(DestroySampler) /* 43 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetSamplerStates) /* 44 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetSamplerBorderColor) /* 45 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetSamplerTexture) /* 46 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetViewport) /* 47 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetScissor) /* 48 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetPointLineRaster) /* 49 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetPolygonRaster) /* 50 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetPolygonOffset) /* 51 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetAlphaTest) /* 52 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetDepthTest) /* 53 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetStencilTest) /* 54 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetBlending) /* 55 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetBlendingColor) /* 56 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetColorWrite) /* 57 */ \ + O3D_COMMAND_BUFFER_CMD_OP(CreateRenderSurface) /* 58 */ \ + O3D_COMMAND_BUFFER_CMD_OP(DestroyRenderSurface) /* 59 */ \ + O3D_COMMAND_BUFFER_CMD_OP(CreateDepthSurface) /* 60 */ \ + O3D_COMMAND_BUFFER_CMD_OP(DestroyDepthSurface) /* 61 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetRenderSurface) /* 62 */ \ + O3D_COMMAND_BUFFER_CMD_OP(SetBackSurfaces) /* 63 */ \ // GAPI commands. enum CommandId { - #define O3D_COMMAND_BUFFER_CMD_OP(name) name, + #define O3D_COMMAND_BUFFER_CMD_OP(name) k ## name, O3D_COMMAND_BUFFER_CMDS @@ -359,40 +424,191 @@ namespace cmd { // structures. O3D_PUSH_STRUCTURE_PACKING_1; +// Gets the address of memory just after a structure in a typesafe way. This is +// used for IMMEDIATE commands to get the address of the place to put the data. +// Immediate command put their data direclty in the command buffer. +// Parameters: +// cmd: Address of command. +template <typename T> +void* ImmediateDataAddress(T* cmd) { + COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); + return reinterpret_cast<char*>(cmd) + sizeof(*cmd); +} + +// Gets the address of the place to put the next command in a typesafe way. +// This can only be used for fixed sized commands. +template <typename T> +// Parameters: +// cmd: Address of command. +void* NextCmdAddress(void* cmd) { + COMPILE_ASSERT(T::kArgFlags == cmd::kFixed, Cmd_kArgFlags_not_kFixed); + return reinterpret_cast<char*>(cmd) + sizeof(T); +} + +// Gets the address of the place to put the next command in a typesafe way. +// This can only be used for variable sized command like IMMEDIATE commands. +// Parameters: +// cmd: Address of command. +// size_of_data_in_bytes: Size of the data for the command. +template <typename T> +void* NextImmediateCmdAddress(void* cmd, uint32 size_of_data_in_bytes) { + COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); + return reinterpret_cast<char*>(cmd) + sizeof(T) + // NOLINT + RoundSizeToMultipleOfEntries(size_of_data_in_bytes); +} + enum ArgFlags { kFixed = 0x0, kAtLeastN = 0x1, }; struct SharedMemory { + void Init(uint32 _id, uint32 _offset) { + id = _id; + offset = _offset; + } + uint32 id; uint32 offset; }; -struct NOOP { - static const CommandId kCmdId = command_buffer::NOOP; +COMPILE_ASSERT(offsetof(SharedMemory, id) == 0, + Offsetof_SharedMemory_id_not_0); +COMPILE_ASSERT(offsetof(SharedMemory, offset) == 4, + Offsetof_SharedMemory_offset_not_4); + +struct Noop { + typedef Noop ValueType; + static const CommandId kCmdId = command_buffer::kNoop; static const ArgFlags kArgFlags = kAtLeastN; + + void SetHeader(uint32 skip_count) { + header.Init(kCmdId, skip_count + 1); + } + + void Init(uint32 skip_count) { + SetHeader(skip_count); + } + + static void* Set(void* cmd, uint32 skip_count) { + static_cast<ValueType*>(cmd)->Init(skip_count); + return NextImmediateCmdAddress<ValueType>( + cmd, skip_count * sizeof(CommandBufferEntry)); // NOLINT + } + + CommandHeader header; }; -struct SET_TOKEN { - static const CommandId kCmdId = command_buffer::SET_TOKEN; +COMPILE_ASSERT(sizeof(Noop) == 4, Sizeof_Noop_is_not_4); +COMPILE_ASSERT(offsetof(Noop, header) == 0, Offsetof_Noop_header_not_0); + +struct SetToken { + typedef SetToken ValueType; + static const CommandId kCmdId = command_buffer::kSetToken; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _token) { + SetHeader(); + token = _token; + } + static void* Set(void* cmd, uint32 token) { + static_cast<ValueType*>(cmd)->Init(token); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 token; }; -struct BEGIN_FRAME { - static const CommandId kCmdId = command_buffer::BEGIN_FRAME; +COMPILE_ASSERT(sizeof(SetToken) == 8, Sizeof_SetToken_is_not_8); +COMPILE_ASSERT(offsetof(SetToken, header) == 0, + Offsetof_SetToken_header_not_0); +COMPILE_ASSERT(offsetof(SetToken, token) == 4, + Offsetof_SetToken_token_not_4); + +struct BeginFrame { + typedef BeginFrame ValueType; + static const CommandId kCmdId = command_buffer::kBeginFrame; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init() { + SetHeader(); + } + static void* Set(void* cmd) { + static_cast<ValueType*>(cmd)->Init(); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; }; -struct END_FRAME { - static const CommandId kCmdId = command_buffer::END_FRAME; +COMPILE_ASSERT(sizeof(BeginFrame) == 4, Sizeof_BeginFrame_is_not_4); +COMPILE_ASSERT(offsetof(BeginFrame, header) == 0, + OffsetOf_BeginFrame_header_not_0); + +struct EndFrame { + typedef EndFrame ValueType; + static const CommandId kCmdId = command_buffer::kEndFrame; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init() { + SetHeader(); + } + static void* Set(void* cmd) { + static_cast<ValueType*>(cmd)->Init(); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; }; -struct CLEAR { - static const CommandId kCmdId = command_buffer::CLEAR; +COMPILE_ASSERT(sizeof(EndFrame) == 4, Sizeof_EndFrame_is_not_4); +COMPILE_ASSERT(offsetof(EndFrame, header) == 0, + OffsetOf_EndFrame_header_not_0); + +struct Clear { + typedef Clear ValueType; + static const CommandId kCmdId = command_buffer::kClear; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _buffers, float _red, float _green, float _blue, + float _alpha, float _depth, uint32 _stencil) { + SetHeader(); + buffers = _buffers; + red = _red; + green = _green; + blue = _blue; + alpha = _alpha; + depth = _depth; + stencil = _stencil; + } + + static void* Set(void* cmd, uint32 buffers, + float red, float green, float blue, float alpha, + float depth, + uint32 stencil) { + static_cast<ValueType*>(cmd)->Init( + buffers, red, green, blue, alpha, depth, stencil); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 buffers; float red; float green; @@ -402,9 +618,67 @@ struct CLEAR { uint32 stencil; }; -struct SET_VIEWPORT { - static const CommandId kCmdId = command_buffer::SET_VIEWPORT; +COMPILE_ASSERT(sizeof(Clear) == 32, Sizeof_Clear_is_not_32); +COMPILE_ASSERT(offsetof(Clear, header) == 0, + OffsetOf_Clear_header_not_0); +COMPILE_ASSERT(offsetof(Clear, buffers) == 4, + OffsetOf_Clear_buffers_not_4); +COMPILE_ASSERT(offsetof(Clear, red) == 8, + OffsetOf_Clear_red_not_8); +COMPILE_ASSERT(offsetof(Clear, green) == 12, + OffsetOf_Clear_green_not_12); +COMPILE_ASSERT(offsetof(Clear, blue) == 16, + OffsetOf_Clear_blue_not_16); +COMPILE_ASSERT(offsetof(Clear, alpha) == 20, + OffsetOf_Clear_alpha_not_20); +COMPILE_ASSERT(offsetof(Clear, depth) == 24, + OffsetOf_Clear_depth_not_24); +COMPILE_ASSERT(offsetof(Clear, stencil) == 28, + OffsetOf_Clear_stencil_not_28); + +struct SetViewport { + typedef SetViewport ValueType; + static const CommandId kCmdId = command_buffer::kSetViewport; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + uint32 _left, + uint32 _top, + uint32 _width, + uint32 _height, + float _z_min, + float _z_max) { + SetHeader(); + left = _left; + top = _top; + width = _width; + height = _height; + z_min = _z_min; + z_max = _z_max; + } + + static void* Set(void* cmd, + uint32 left, + uint32 top, + uint32 width, + uint32 height, + float z_min, + float z_max) { + static_cast<ValueType*>(cmd)->Init( + left, + top, + width, + height, + z_min, + z_max); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 left; uint32 top; uint32 width; @@ -413,119 +687,659 @@ struct SET_VIEWPORT { float z_max; }; -struct CREATE_VERTEX_BUFFER { - static const CommandId kCmdId = command_buffer::CREATE_VERTEX_BUFFER; +COMPILE_ASSERT(sizeof(SetViewport) == 28, Sizeof_SetViewport_is_not_28); +COMPILE_ASSERT(offsetof(SetViewport, header) == 0, + OffsetOf_SetViewport_header_not_0); +COMPILE_ASSERT(offsetof(SetViewport, left) == 4, + OffsetOf_SetViewport_left_not_4); +COMPILE_ASSERT(offsetof(SetViewport, top) == 8, + OffsetOf_SetViewport_top_not_8); +COMPILE_ASSERT(offsetof(SetViewport, width) == 12, + OffsetOf_SetViewport_width_not_12); +COMPILE_ASSERT(offsetof(SetViewport, height) == 16, + OffsetOf_SetViewport_height_not_16); +COMPILE_ASSERT(offsetof(SetViewport, z_min) == 20, + OffsetOf_SetViewport_z_min_not_20); +COMPILE_ASSERT(offsetof(SetViewport, z_max) == 24, + OffsetOf_SetViewport_z_max_not_24); + +struct CreateVertexBuffer { + typedef CreateVertexBuffer ValueType; + static const CommandId kCmdId = command_buffer::kCreateVertexBuffer; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _size, uint32 _flags) { + SetHeader(); + id = _id; + size = _size; + flags = _flags; + } + + static void* Set(void* cmd, uint32 id, uint32 size, uint32 flags) { + static_cast<ValueType*>(cmd)->Init(id, size, flags); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; uint32 size; uint32 flags; }; -struct DESTROY_VERTEX_BUFFER { - static const CommandId kCmdId = command_buffer::DESTROY_VERTEX_BUFFER; +COMPILE_ASSERT(sizeof(CreateVertexBuffer) == 16, + Sizeof_CreateVertexBuffer_is_not_16); +COMPILE_ASSERT(offsetof(CreateVertexBuffer, header) == 0, + OffsetOf_CreateVertexBuffer_header_not_0); +COMPILE_ASSERT(offsetof(CreateVertexBuffer, id) == 4, + OffsetOf_CreateVertexBuffer_id_not_4); +COMPILE_ASSERT(offsetof(CreateVertexBuffer, size) == 8, + OffsetOf_CreateVertexBuffer_size_not_8); +COMPILE_ASSERT(offsetof(CreateVertexBuffer, flags) == 12, + OffsetOf_CreateVertexBuffer_flags_not_12); + +struct DestroyVertexBuffer { + typedef DestroyVertexBuffer ValueType; + static const CommandId kCmdId = command_buffer::kDestroyVertexBuffer; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id) { + SetHeader(); + id = _id; + } + + static void* Set(void* cmd, uint32 id) { + static_cast<ValueType*>(cmd)->Init(id); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; }; -struct SET_VERTEX_BUFFER_DATA_IMMEDIATE { - static const CommandId kCmdId = command_buffer::SET_VERTEX_BUFFER_DATA_IMMEDIATE; +COMPILE_ASSERT(sizeof(DestroyVertexBuffer) == 8, + Sizeof_DestroyVertexBuffer_is_not_8); +COMPILE_ASSERT(offsetof(DestroyVertexBuffer, header) == 0, + OffsetOf_DestroyVertexBuffer_header_not_0); +COMPILE_ASSERT(offsetof(DestroyVertexBuffer, id) == 4, + OffsetOf_DestroyVertexBuffer_id_not_4); + +struct SetVertexBufferDataImmediate { + typedef SetVertexBufferDataImmediate ValueType; + static const CommandId kCmdId = command_buffer::kSetVertexBufferDataImmediate; static const ArgFlags kArgFlags = kAtLeastN; + + void SetHeader(uint32 size) { + header.SetCmdBySize<ValueType>(size); + } + + void Init(uint32 _id, uint32 _offset, const void* data, uint32 size) { + SetHeader(size); + id = _id; + offset = _offset; + memcpy(ImmediateDataAddress(this), data, size); + } + + static void* Set(void* cmd, uint32 id, uint32 offset, + const void* data, uint32 size) { + static_cast<ValueType*>(cmd)->Init(id, offset, data, size); + return NextImmediateCmdAddress<ValueType>(cmd, size); + } + + CommandHeader header; uint32 id; uint32 offset; }; -struct SET_VERTEX_BUFFER_DATA { - static const CommandId kCmdId = command_buffer::SET_VERTEX_BUFFER_DATA; +COMPILE_ASSERT(sizeof(SetVertexBufferDataImmediate) == 12, + Sizeof_SetVertexBufferDataImmediate_is_not_12); +COMPILE_ASSERT(offsetof(SetVertexBufferDataImmediate, header) == 0, + OffsetOf_SetVertexBufferDataImmediate_header_not_0); +COMPILE_ASSERT(offsetof(SetVertexBufferDataImmediate, id) == 4, + OffsetOf_SetVertexBufferDataImmediate_id_not_4); +COMPILE_ASSERT(offsetof(SetVertexBufferDataImmediate, offset) == 8, + OffsetOf_SetVertexBufferDataImmediate_offset_not_8); + +struct SetVertexBufferData { + typedef SetVertexBufferData ValueType; + static const CommandId kCmdId = command_buffer::kSetVertexBufferData; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _offset, uint32 _size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + SetHeader(); + id = _id; + offset = _offset; + size = _size; + shared_memory.Init(shared_memory_id, shared_memory_offset); + } + + static void* Set(void* cmd, uint32 id, uint32 offset, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + static_cast<ValueType*>(cmd)->Init(id, offset, size, + shared_memory_id, shared_memory_offset); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; uint32 offset; uint32 size; SharedMemory shared_memory; }; -struct GET_VERTEX_BUFFER_DATA { - static const CommandId kCmdId = command_buffer::GET_VERTEX_BUFFER_DATA; +COMPILE_ASSERT(sizeof(SetVertexBufferData) == 24, + Sizeof_SetVertexBufferData_is_not_24); +COMPILE_ASSERT(offsetof(SetVertexBufferData, header) == 0, + OffsetOf_SetVertexBufferData_header_not_0); +COMPILE_ASSERT(offsetof(SetVertexBufferData, id) == 4, + OffsetOf_SetVertexBufferData_id_not_4); +COMPILE_ASSERT(offsetof(SetVertexBufferData, offset) == 8, + OffsetOf_SetVertexBufferData_offset_not_8); +COMPILE_ASSERT(offsetof(SetVertexBufferData, size) == 12, + OffsetOf_SetVertexBufferData_size_not_12); +COMPILE_ASSERT(offsetof(SetVertexBufferData, shared_memory) == 16, + OffsetOf_SetVertexBufferData_shared_memory_not_16); + +struct GetVertexBufferData { + typedef GetVertexBufferData ValueType; + static const CommandId kCmdId = command_buffer::kGetVertexBufferData; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _offset, uint32 _size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + SetHeader(); + id = _id; + offset = _offset; + size = _size; + shared_memory.Init(shared_memory_id, shared_memory_offset); + } + + static void* Set(void* cmd, uint32 id, uint32 offset, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + static_cast<ValueType*>(cmd)->Init(id, offset, size, + shared_memory_id, shared_memory_offset); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; uint32 offset; uint32 size; SharedMemory shared_memory; }; -struct CREATE_INDEX_BUFFER { - static const CommandId kCmdId = command_buffer::CREATE_INDEX_BUFFER; +COMPILE_ASSERT(sizeof(GetVertexBufferData) == 24, + Sizeof_GetVertexBufferData_is_not_24); +COMPILE_ASSERT(offsetof(GetVertexBufferData, header) == 0, + OffsetOf_GetVertexBufferData_header_not_0); +COMPILE_ASSERT(offsetof(GetVertexBufferData, id) == 4, + OffsetOf_GetVertexBufferData_id_not_4); +COMPILE_ASSERT(offsetof(GetVertexBufferData, offset) == 8, + OffsetOf_GetVertexBufferData_offset_not_8); +COMPILE_ASSERT(offsetof(GetVertexBufferData, size) == 12, + OffsetOf_GetVertexBufferData_size_not_12); +COMPILE_ASSERT(offsetof(GetVertexBufferData, shared_memory) == 16, + OffsetOf_GetVertexBufferData_shared_memory_not_16); + +struct CreateIndexBuffer { + typedef CreateIndexBuffer ValueType; + static const CommandId kCmdId = command_buffer::kCreateIndexBuffer; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _size, uint32 _flags) { + SetHeader(); + id = _id; + size = _size; + flags = _flags; + } + + static void* Set(void* cmd, uint32 id, uint32 size, uint32 flags) { + static_cast<ValueType*>(cmd)->Init(id, size, flags); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; uint32 size; uint32 flags; }; -struct DESTROY_INDEX_BUFFER { - static const CommandId kCmdId = command_buffer::DESTROY_INDEX_BUFFER; +COMPILE_ASSERT(sizeof(CreateIndexBuffer) == 16, + Sizeof_CreateIndexBuffer_is_not_16); +COMPILE_ASSERT(offsetof(CreateIndexBuffer, header) == 0, + OffsetOf_CreateIndexBuffer_header_not_0); +COMPILE_ASSERT(offsetof(CreateIndexBuffer, id) == 4, + OffsetOf_CreateIndexBuffer_id_not_4); +COMPILE_ASSERT(offsetof(CreateIndexBuffer, size) == 8, + OffsetOf_CreateIndexBuffer_size_not_8); +COMPILE_ASSERT(offsetof(CreateIndexBuffer, flags) == 12, + OffsetOf_CreateIndexBuffer_flags_not_12); + +struct DestroyIndexBuffer { + typedef DestroyIndexBuffer ValueType; + static const CommandId kCmdId = command_buffer::kDestroyIndexBuffer; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id) { + SetHeader(); + id = _id; + } + + static void* Set(void* cmd, uint32 id) { + static_cast<ValueType*>(cmd)->Init(id); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; }; -struct SET_INDEX_BUFFER_DATA_IMMEDIATE { - static const CommandId kCmdId = command_buffer::SET_INDEX_BUFFER_DATA_IMMEDIATE; +COMPILE_ASSERT(sizeof(DestroyIndexBuffer) == 8, + Sizeof_DestroyIndexBuffer_is_not_8); +COMPILE_ASSERT(offsetof(DestroyIndexBuffer, header) == 0, + OffsetOf_DestroyIndexBuffer_header_not_0); +COMPILE_ASSERT(offsetof(DestroyIndexBuffer, id) == 4, + OffsetOf_DestroyIndexBuffer_id_not_4); + +struct SetIndexBufferDataImmediate { + typedef SetIndexBufferDataImmediate ValueType; + static const CommandId kCmdId = command_buffer::kSetIndexBufferDataImmediate; static const ArgFlags kArgFlags = kAtLeastN; + + void SetHeader(uint32 size) { + header.SetCmdBySize<ValueType>(size); + } + + void Init(uint32 _id, uint32 _offset, const void* data, uint32 size) { + SetHeader(size); + id = _id; + offset = _offset; + memcpy(ImmediateDataAddress(this), data, size); + } + + static void* Set(void* cmd, uint32 id, uint32 offset, const void* data, + uint32 size) { + static_cast<ValueType*>(cmd)->Init(id, offset, data, size); + return NextImmediateCmdAddress<ValueType>(cmd, size); + } + + CommandHeader header; uint32 id; uint32 offset; }; -struct SET_INDEX_BUFFER_DATA { - static const CommandId kCmdId = command_buffer::SET_INDEX_BUFFER_DATA; +COMPILE_ASSERT(sizeof(SetIndexBufferDataImmediate) == 12, + Sizeof_SetIndexBufferDataImmediate_is_not_12); +COMPILE_ASSERT(offsetof(SetIndexBufferDataImmediate, header) == 0, + OffsetOf_SetIndexBufferDataImmediate_header_not_0); +COMPILE_ASSERT(offsetof(SetIndexBufferDataImmediate, id) == 4, + OffsetOf_SetIndexBufferDataImmediate_id_not_4); +COMPILE_ASSERT(offsetof(SetIndexBufferDataImmediate, offset) == 8, + OffsetOf_SetIndexBufferDataImmediate_offset_not_8); + +struct SetIndexBufferData { + typedef SetIndexBufferData ValueType; + static const CommandId kCmdId = command_buffer::kSetIndexBufferData; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _offset, uint32 _size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + SetHeader(); + id = _id; + offset = _offset; + size = _size; + shared_memory.Init(shared_memory_id, shared_memory_offset); + } + + static void* Set(void* cmd, uint32 id, uint32 offset, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + static_cast<ValueType*>(cmd)->Init(id, offset, size, + shared_memory_id, shared_memory_offset); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; uint32 offset; uint32 size; SharedMemory shared_memory; }; -struct GET_INDEX_BUFFER_DATA { - static const CommandId kCmdId = command_buffer::GET_INDEX_BUFFER_DATA; +COMPILE_ASSERT(sizeof(SetIndexBufferData) == 24, + Sizeof_SetIndexBufferData_is_not_24); +COMPILE_ASSERT(offsetof(SetIndexBufferData, header) == 0, + OffsetOf_SetIndexBufferData_header_not_0); +COMPILE_ASSERT(offsetof(SetIndexBufferData, id) == 4, + OffsetOf_SetIndexBufferData_id_not_4); +COMPILE_ASSERT(offsetof(SetIndexBufferData, offset) == 8, + OffsetOf_SetIndexBufferData_offset_not_8); +COMPILE_ASSERT(offsetof(SetIndexBufferData, size) == 12, + OffsetOf_SetIndexBufferData_size_not_12); +COMPILE_ASSERT(offsetof(SetIndexBufferData, shared_memory) == 16, + OffsetOf_SetIndexBufferData_shared_memory_not_16); + +struct GetIndexBufferData { + typedef GetIndexBufferData ValueType; + static const CommandId kCmdId = command_buffer::kGetIndexBufferData; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _offset, uint32 _size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + SetHeader(); + id = _id; + offset = _offset; + size = _size; + shared_memory.Init(shared_memory_id, shared_memory_offset); + } + + static void* Set(void* cmd, uint32 id, uint32 offset, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + static_cast<ValueType*>(cmd)->Init(id, offset, size, + shared_memory_id, shared_memory_offset); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; uint32 offset; uint32 size; SharedMemory shared_memory; }; -struct CREATE_VERTEX_STRUCT { - static const CommandId kCmdId = command_buffer::CREATE_VERTEX_STRUCT; +COMPILE_ASSERT(sizeof(GetIndexBufferData) == 24, + Sizeof_GetIndexBufferData_is_not_24); +COMPILE_ASSERT(offsetof(GetIndexBufferData, header) == 0, + OffsetOf_GetIndexBufferData_header_not_0); +COMPILE_ASSERT(offsetof(GetIndexBufferData, id) == 4, + OffsetOf_GetIndexBufferData_id_not_4); +COMPILE_ASSERT(offsetof(GetIndexBufferData, offset) == 8, + OffsetOf_GetIndexBufferData_offset_not_8); +COMPILE_ASSERT(offsetof(GetIndexBufferData, size) == 12, + OffsetOf_GetIndexBufferData_size_not_12); +COMPILE_ASSERT(offsetof(GetIndexBufferData, shared_memory) == 16, + OffsetOf_GetIndexBufferData_shared_memory_not_16); + +struct CreateVertexStruct { + typedef CreateVertexStruct ValueType; + static const CommandId kCmdId = command_buffer::kCreateVertexStruct; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _input_count) { + SetHeader(); + id = _id; + input_count = _input_count; + } + + static void* Set(void* cmd, uint32 id, uint32 input_count) { + static_cast<ValueType*>(cmd)->Init(id, input_count); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; uint32 input_count; }; -struct DESTROY_VERTEX_STRUCT { - static const CommandId kCmdId = command_buffer::DESTROY_VERTEX_STRUCT; +COMPILE_ASSERT(sizeof(CreateVertexStruct) == 12, + Sizeof_CreateVertexStruct_is_not_12); +COMPILE_ASSERT(offsetof(CreateVertexStruct, header) == 0, + OffsetOf_CreateVertexStruct_header_not_0); +COMPILE_ASSERT(offsetof(CreateVertexStruct, id) == 4, + OffsetOf_CreateVertexStruct_id_not_4); +COMPILE_ASSERT(offsetof(CreateVertexStruct, input_count) == 8, + OffsetOf_CreateVertexStruct_input_count_not_8); + +struct DestroyVertexStruct { + typedef DestroyVertexStruct ValueType; + static const CommandId kCmdId = command_buffer::kDestroyVertexStruct; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id) { + SetHeader(); + id = _id; + } + + static void* Set(void* cmd, uint32 id) { + static_cast<ValueType*>(cmd)->Init(id); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; }; -struct SET_VERTEX_INPUT { - static const CommandId kCmdId = command_buffer::SET_VERTEX_INPUT; - static const ArgFlags kArgFlags = kAtLeastN; -}; +COMPILE_ASSERT(sizeof(DestroyVertexStruct) == 8, + Sizeof_DestroyVertexStruct_is_not_8); +COMPILE_ASSERT(offsetof(DestroyVertexStruct, header) == 0, + OffsetOf_DestroyVertexStruct_header_not_0); +COMPILE_ASSERT(offsetof(DestroyVertexStruct, id) == 4, + OffsetOf_DestroyVertexStruct_id_not_4); -struct SET_VERTEX_STRUCT { - static const CommandId kCmdId = command_buffer::SET_VERTEX_STRUCT; +struct SetVertexInput { + typedef SetVertexInput ValueType; + static const CommandId kCmdId = command_buffer::kSetVertexInput; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _vertex_struct_id, + uint32 _input_index, + uint32 _vertex_buffer_id, + uint32 _offset, + uint8 _semantic, + uint32 _semantic_index, + uint8 _type, + uint32 _stride) { + SetHeader(); + vertex_struct_id = _vertex_struct_id; + input_index = _input_index; + vertex_buffer_id = _vertex_buffer_id; + offset = _offset; + fixme4 = + set_vertex_input_cmd::Semantic::MakeValue(_semantic) | + set_vertex_input_cmd::SemanticIndex::MakeValue(_semantic_index) | + set_vertex_input_cmd::Type::MakeValue(_type) | + set_vertex_input_cmd::Stride::MakeValue(_stride); + } + + static void* Set( + void* cmd, + uint32 vertex_struct_id, + uint32 input_index, + uint32 vertex_buffer_id, + uint32 offset, + uint8 semantic, + uint32 semantic_index, + uint8 type, + uint32 stride) { + static_cast<ValueType*>(cmd)->Init( + vertex_struct_id, + input_index, + vertex_buffer_id, + offset, + semantic, + semantic_index, + type, + stride); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; + uint32 vertex_struct_id; + uint32 input_index; + uint32 vertex_buffer_id; + uint32 offset; + uint32 fixme4; +}; + +COMPILE_ASSERT(sizeof(SetVertexInput) == 24, + Sizeof_SetVertexInput_is_not_24); +COMPILE_ASSERT(offsetof(SetVertexInput, header) == 0, + OffsetOf_SetVertexInput_header_not_0); +COMPILE_ASSERT(offsetof(SetVertexInput, vertex_struct_id) == 4, + OffsetOf_SetVertexInput_vertex_struct_id_not_4); +COMPILE_ASSERT(offsetof(SetVertexInput, input_index) == 8, + OffsetOf_SetVertexInput_input_index_not_8); +COMPILE_ASSERT(offsetof(SetVertexInput, vertex_buffer_id) == 12, + OffsetOf_SetVertexInput_vertex_buffer_id_not_12); +COMPILE_ASSERT(offsetof(SetVertexInput, offset) == 16, + OffsetOf_SetVertexInput_offset_not_16); +COMPILE_ASSERT(offsetof(SetVertexInput, fixme4) == 20, + OffsetOf_SetVertexInput_fixme4_not_20); + +struct SetVertexStruct { + typedef SetVertexStruct ValueType; + static const CommandId kCmdId = command_buffer::kSetVertexStruct; + static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id) { + SetHeader(); + id = _id; + } + + static void* Set(void* cmd, uint32 id) { + static_cast<ValueType*>(cmd)->Init(id); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; }; -struct DRAW { - static const CommandId kCmdId = command_buffer::DRAW; +COMPILE_ASSERT(sizeof(SetVertexStruct) == 8, + Sizeof_SetVertexStruct_is_not_8); +COMPILE_ASSERT(offsetof(SetVertexStruct, header) == 0, + OffsetOf_SetVertexStruct_header_not_0); +COMPILE_ASSERT(offsetof(SetVertexStruct, id) == 4, + OffsetOf_SetVertexStruct_id_not_4); + +struct Draw { + typedef Draw ValueType; + static const CommandId kCmdId = command_buffer::kDraw; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _primitive_type, uint32 _first, uint32 _count) { + SetHeader(); + primitive_type = _primitive_type; + first = _first; + count = _count; + } + + static void* Set(void* cmd, uint32 primitive_type, uint32 first, + uint32 count) { + static_cast<ValueType*>(cmd)->Init(primitive_type, first, count); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 primitive_type; uint32 first; uint32 count; }; -struct DRAW_INDEXED { - static const CommandId kCmdId = command_buffer::DRAW_INDEXED; +COMPILE_ASSERT(sizeof(Draw) == 16, Sizeof_DRAW_is_not_16); +COMPILE_ASSERT(offsetof(Draw, header) == 0, + OffsetOf_Draw_header_not_0); +COMPILE_ASSERT(offsetof(Draw, primitive_type) == 4, + OffsetOf_Draw_primitive_type_not_4); +COMPILE_ASSERT(offsetof(Draw, first) == 8, + OffsetOf_Draw_first_not_8); +COMPILE_ASSERT(offsetof(Draw, count) == 12, + OffsetOf_Draw_count_not_12); + +struct DrawIndexed { + typedef DrawIndexed ValueType; + static const CommandId kCmdId = command_buffer::kDrawIndexed; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + uint32 _primitive_type, + uint32 _index_buffer_id, + uint32 _first, + uint32 _count, + uint32 _min_index, + uint32 _max_index) { + SetHeader(); + primitive_type = _primitive_type; + index_buffer_id = _index_buffer_id; + first = _first; + count = _count; + min_index = _min_index; + max_index = _max_index; + } + + static void* Set(void* cmd, + uint32 primitive_type, + uint32 index_buffer_id, + uint32 first, + uint32 count, + uint32 min_index, + uint32 max_index) { + static_cast<ValueType*>(cmd)->Init( + primitive_type, + index_buffer_id, + first, + count, + min_index, + max_index); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 primitive_type; uint32 index_buffer_id; uint32 first; @@ -534,175 +1348,1218 @@ struct DRAW_INDEXED { uint32 max_index; }; -struct CREATE_EFFECT { - static const CommandId kCmdId = command_buffer::CREATE_EFFECT; +COMPILE_ASSERT(sizeof(DrawIndexed) == 28, Sizeof_DrawIndexed_is_not_28); +COMPILE_ASSERT(offsetof(DrawIndexed, header) == 0, + OffsetOf_DrawIndexed_header_not_0); +COMPILE_ASSERT(offsetof(DrawIndexed, primitive_type) == 4, + OffsetOf_DrawIndexed_primitive_type_not_4); +COMPILE_ASSERT(offsetof(DrawIndexed, index_buffer_id) == 8, + OffsetOf_DrawIndexed_index_buffer_id_not_8); +COMPILE_ASSERT(offsetof(DrawIndexed, first) == 12, + OffsetOf_DrawIndexed_first_not_12); +COMPILE_ASSERT(offsetof(DrawIndexed, count) == 16, + OffsetOf_DrawIndexed_count_not_16); +COMPILE_ASSERT(offsetof(DrawIndexed, min_index) == 20, + OffsetOf_DrawIndexed_min_index_not_20); +COMPILE_ASSERT(offsetof(DrawIndexed, max_index) == 24, + OffsetOf_DrawIndexed_max_index_not_24); + +struct CreateEffect { + typedef CreateEffect ValueType; + static const CommandId kCmdId = command_buffer::kCreateEffect; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + SetHeader(); + id = _id; + size = _size; + shared_memory.Init(shared_memory_id, shared_memory_offset); + } + + static void* Set(void* cmd, uint32 id, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + static_cast<ValueType*>(cmd)->Init(id, size, + shared_memory_id, shared_memory_offset); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; uint32 size; SharedMemory shared_memory; }; -struct CREATE_EFFECT_IMMEDIATE { - static const CommandId kCmdId = command_buffer::CREATE_EFFECT_IMMEDIATE; +COMPILE_ASSERT(sizeof(CreateEffect) == 20, Sizeof_CreateEffect_is_not_20); +COMPILE_ASSERT(offsetof(CreateEffect, header) == 0, + OffsetOf_CreateEffect_header_not_0); +COMPILE_ASSERT(offsetof(CreateEffect, id) == 4, + OffsetOf_CreateEffect_id_not_4); +COMPILE_ASSERT(offsetof(CreateEffect, size) == 8, + OffsetOf_CreateEffect_size_not_8); +COMPILE_ASSERT(offsetof(CreateEffect, shared_memory) == 12, + OffsetOf_CreateEffect_shared_memory_not_12); + +struct CreateEffectImmediate { + typedef CreateEffectImmediate ValueType; + static const CommandId kCmdId = command_buffer::kCreateEffectImmediate; static const ArgFlags kArgFlags = kAtLeastN; + + void SetHeader(uint32 size) { + header.SetCmdBySize<ValueType>(size); + } + + void Init(uint32 _id, uint32 _size, const void* data) { + SetHeader(_size); + id = _id; + size = _size; + } + + static void* Set(void* cmd, uint32 id, uint32 size, const void* data) { + static_cast<ValueType*>(cmd)->Init(id, size, data); + return NextImmediateCmdAddress<ValueType>(cmd, size); + } + + CommandHeader header; uint32 id; uint32 size; }; -struct DESTROY_EFFECT { - static const CommandId kCmdId = command_buffer::DESTROY_EFFECT; +COMPILE_ASSERT(sizeof(CreateEffectImmediate) == 12, + Sizeof_CreateEffectImmediate_is_not_12); +COMPILE_ASSERT(offsetof(CreateEffectImmediate, header) == 0, + OffsetOf_CreateEffectImmediate_header_not_0); +COMPILE_ASSERT(offsetof(CreateEffectImmediate, id) == 4, + OffsetOf_CreateEffectImmediate_id_not_4); +COMPILE_ASSERT(offsetof(CreateEffectImmediate, size) == 8, + OffsetOf_CreateEffectImmediate_size_not_8); + +struct DestroyEffect { + typedef DestroyEffect ValueType; + static const CommandId kCmdId = command_buffer::kDestroyEffect; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id) { + SetHeader(); + id = _id; + } + + static void* Set(void* cmd, uint32 id) { + static_cast<ValueType*>(cmd)->Init(id); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; }; -struct SET_EFFECT { - static const CommandId kCmdId = command_buffer::SET_EFFECT; +COMPILE_ASSERT(sizeof(DestroyEffect) == 8, Sizeof_DestroyEffect_is_not_8); +COMPILE_ASSERT(offsetof(DestroyEffect, header) == 0, + OffsetOf_DestroyEffect_header_not_0); +COMPILE_ASSERT(offsetof(DestroyEffect, id) == 4, + OffsetOf_DestroyEffect_id_not_4); + +struct SetEffect { + typedef SetEffect ValueType; + static const CommandId kCmdId = command_buffer::kSetEffect; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id) { + SetHeader(); + id = _id; + } + + static void* Set(void* cmd, uint32 id) { + static_cast<ValueType*>(cmd)->Init(id); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; }; -struct GET_PARAM_COUNT { - static const CommandId kCmdId = command_buffer::GET_PARAM_COUNT; +COMPILE_ASSERT(sizeof(SetEffect) == 8, Sizeof_SetEffect_is_not_8); +COMPILE_ASSERT(offsetof(SetEffect, header) == 0, + OffsetOf_SetEffect_header_not_0); +COMPILE_ASSERT(offsetof(SetEffect, id) == 4, + OffsetOf_SetEffect_id_not_4); + +struct GetParamCount { + typedef GetParamCount ValueType; + static const CommandId kCmdId = command_buffer::kGetParamCount; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + SetHeader(); + id = _id; + size = _size; + shared_memory.Init(shared_memory_id, shared_memory_offset); + } + + static void* Set(void* cmd, uint32 id, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + static_cast<ValueType*>(cmd)->Init(id, size, + shared_memory_id, shared_memory_offset); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; uint32 size; SharedMemory shared_memory; }; -struct CREATE_PARAM { - static const CommandId kCmdId = command_buffer::CREATE_PARAM; +COMPILE_ASSERT(sizeof(GetParamCount) == 20, Sizeof_GetParamCount_is_not_20); +COMPILE_ASSERT(offsetof(GetParamCount, header) == 0, + OffsetOf_GetParamCount_header_not_0); +COMPILE_ASSERT(offsetof(GetParamCount, id) == 4, + OffsetOf_GetParamCount_id_not_4); +COMPILE_ASSERT(offsetof(GetParamCount, size) == 8, + OffsetOf_GetParamCount_size_not_8); +COMPILE_ASSERT(offsetof(GetParamCount, shared_memory) == 12, + OffsetOf_GetParamCount_shared_memory_not_12); + +struct CreateParam { + typedef CreateParam ValueType; + static const CommandId kCmdId = command_buffer::kCreateParam; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _param_id, uint32 _effect_id, uint32 _index) { + SetHeader(); + param_id = _param_id; + effect_id = _effect_id; + index = _index; + } + + static void* Set(void* cmd, + uint32 param_id, uint32 effect_id, uint32 index) { + static_cast<ValueType*>(cmd)->Init(param_id, effect_id, index); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 param_id; uint32 effect_id; uint32 index; }; -struct CREATE_PARAM_BY_NAME { - static const CommandId kCmdId = command_buffer::CREATE_PARAM_BY_NAME; +COMPILE_ASSERT(sizeof(CreateParam) == 16, Sizeof_CreateParam_is_not_16); +COMPILE_ASSERT(offsetof(CreateParam, header) == 0, + OffsetOf_CreateParam_header_not_0); +COMPILE_ASSERT(offsetof(CreateParam, param_id) == 4, + OffsetOf_CreateParam_param_id_not_4); +COMPILE_ASSERT(offsetof(CreateParam, effect_id) == 8, + OffsetOf_CreateParam_effect_id_not_8); +COMPILE_ASSERT(offsetof(CreateParam, index) == 12, + OffsetOf_CreateParam_index_not_12); + +struct CreateParamByName { + typedef CreateParamByName ValueType; + static const CommandId kCmdId = command_buffer::kCreateParamByName; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _param_id, uint32 _effect_id, uint32 _size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + SetHeader(); + param_id = _param_id; + effect_id = _effect_id; + size = _size; + shared_memory.Init(shared_memory_id, shared_memory_offset); + } + + static void* Set(void* cmd, uint32 param_id, uint32 effect_id, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + static_cast<ValueType*>(cmd)->Init(param_id, effect_id, size, + shared_memory_id, shared_memory_offset); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 param_id; uint32 effect_id; uint32 size; SharedMemory shared_memory; }; -struct CREATE_PARAM_BY_NAME_IMMEDIATE { - static const CommandId kCmdId = command_buffer::CREATE_PARAM_BY_NAME_IMMEDIATE; +COMPILE_ASSERT(sizeof(CreateParamByName) == 24, + Sizeof_CreateParamByName_is_not_24); +COMPILE_ASSERT(offsetof(CreateParamByName, header) == 0, + OffsetOf_CreateParamByName_header_not_0); +COMPILE_ASSERT(offsetof(CreateParamByName, param_id) == 4, + OffsetOf_CreateParamByName_param_id_not_4); +COMPILE_ASSERT(offsetof(CreateParamByName, effect_id) == 8, + OffsetOf_CreateParamByName_effect_id_not_8); +COMPILE_ASSERT(offsetof(CreateParamByName, size) == 12, + OffsetOf_CreateParamByName_size_not_12); +COMPILE_ASSERT(offsetof(CreateParamByName, shared_memory) == 16, + OffsetOf_CreateParamByName_shared_memory_not_16); + +struct CreateParamByNameImmediate { + typedef CreateParamByNameImmediate ValueType; + static const CommandId kCmdId = command_buffer::kCreateParamByNameImmediate; static const ArgFlags kArgFlags = kAtLeastN; + + void SetHeader(uint32 size) { + header.SetCmdBySize<ValueType>(size); + } + + void Init(uint32 _param_id, uint32 _effect_id, uint32 _size, + const void* data) { + SetHeader(_size); + param_id = _param_id; + effect_id = _effect_id; + size = _size; + memcpy(ImmediateDataAddress(this), data, _size); + } + + static void* Set(void* cmd, uint32 param_id, uint32 effect_id, uint32 size, + const void* data) { + static_cast<ValueType*>(cmd)->Init(param_id, effect_id, size, data); + return NextImmediateCmdAddress<ValueType>(cmd, size); + } + + CommandHeader header; uint32 param_id; uint32 effect_id; uint32 size; }; -struct DESTROY_PARAM { - static const CommandId kCmdId = command_buffer::DESTROY_PARAM; +COMPILE_ASSERT(sizeof(CreateParamByNameImmediate) == 16, + Sizeof_CreateParamByNameImmediate_is_not_16); +COMPILE_ASSERT(offsetof(CreateParamByNameImmediate, header) == 0, + OffsetOf_CreateParamByNameImmediate_header_not_0); +COMPILE_ASSERT(offsetof(CreateParamByNameImmediate, param_id) == 4, + OffsetOf_CreateParamByNameImmediate_param_id_not_4); +COMPILE_ASSERT(offsetof(CreateParamByNameImmediate, effect_id) == 8, + OffsetOf_CreateParamByNameImmediate_effect_id_not_8); +COMPILE_ASSERT(offsetof(CreateParamByNameImmediate, size) == 12, + OffsetOf_CreateParamByNameImmediate_size_not_12); + +struct DestroyParam { + typedef DestroyParam ValueType; + static const CommandId kCmdId = command_buffer::kDestroyParam; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id) { + SetHeader(); + id = _id; + } + + static void* Set(void* cmd, uint32 id) { + static_cast<ValueType*>(cmd)->Init(id); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; }; -struct SET_PARAM_DATA { - static const CommandId kCmdId = command_buffer::SET_PARAM_DATA; +COMPILE_ASSERT(sizeof(DestroyParam) == 8, Sizeof_DestroyParam_is_not_8); +COMPILE_ASSERT(offsetof(DestroyParam, header) == 0, + OffsetOf_DestroyParam_header_not_0); +COMPILE_ASSERT(offsetof(DestroyParam, id) == 4, + OffsetOf_DestroyParam_id_not_4); + +struct SetParamData { + typedef SetParamData ValueType; + static const CommandId kCmdId = command_buffer::kSetParamData; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + SetHeader(); + id = _id; + size = _size; + shared_memory.Init(shared_memory_id, shared_memory_offset); + } + + static void* Set(void* cmd, uint32 id, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + static_cast<ValueType*>(cmd)->Init(id, size, + shared_memory_id, shared_memory_offset); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; uint32 size; SharedMemory shared_memory; }; -struct SET_PARAM_DATA_IMMEDIATE { - static const CommandId kCmdId = command_buffer::SET_PARAM_DATA_IMMEDIATE; +COMPILE_ASSERT(sizeof(SetParamData) == 20, Sizeof_SetParamData_is_not_20); +COMPILE_ASSERT(offsetof(SetParamData, header) == 0, + OffsetOf_SetParamData_header_not_0); +COMPILE_ASSERT(offsetof(SetParamData, id) == 4, + OffsetOf_SetParamData_id_not_4); +COMPILE_ASSERT(offsetof(SetParamData, size) == 8, + OffsetOf_SetParamData_size_not_8); +COMPILE_ASSERT(offsetof(SetParamData, shared_memory) == 12, + OffsetOf_SetParamData_shared_memory_not_12); + +struct SetParamDataImmediate { + typedef SetParamDataImmediate ValueType; + static const CommandId kCmdId = command_buffer::kSetParamDataImmediate; static const ArgFlags kArgFlags = kAtLeastN; + + void SetHeader(uint32 size) { + header.SetCmdBySize<ValueType>(size); + } + + void Init(uint32 _id, uint32 _size, const void* data) { + SetHeader(_size); + id = _id; + size = _size; + memcpy(ImmediateDataAddress(this), data, _size); + } + + static void* Set(void* cmd, uint32 id, uint32 size, const void* data) { + static_cast<ValueType*>(cmd)->Init(id, size, data); + return NextImmediateCmdAddress<ValueType>(cmd, size); + } + + CommandHeader header; uint32 id; uint32 size; }; -struct GET_PARAM_DESC { - static const CommandId kCmdId = command_buffer::GET_PARAM_DESC; +COMPILE_ASSERT(sizeof(SetParamDataImmediate) == 12, + Sizeof_SetParamDataImmediate_is_not_12); +COMPILE_ASSERT(offsetof(SetParamDataImmediate, header) == 0, + OffsetOf_SetParamDataImmediate_header_not_0); +COMPILE_ASSERT(offsetof(SetParamDataImmediate, id) == 4, + OffsetOf_SetParamDataImmediate_id_not_4); +COMPILE_ASSERT(offsetof(SetParamDataImmediate, size) == 8, + OffsetOf_SetParamDataImmediate_size_not_8); + +struct GetParamDesc { + typedef GetParamDesc ValueType; + static const CommandId kCmdId = command_buffer::kGetParamDesc; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + SetHeader(); + id = _id; + size = _size; + shared_memory.Init(shared_memory_id, shared_memory_offset); + } + + static void* Set(void* cmd, uint32 id, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + static_cast<ValueType*>(cmd)->Init(id, size, + shared_memory_id, shared_memory_offset); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; uint32 size; SharedMemory shared_memory; }; -struct GET_STREAM_COUNT { - static const CommandId kCmdId = command_buffer::GET_STREAM_COUNT; +COMPILE_ASSERT(sizeof(GetParamDesc) == 20, Sizeof_GetParamDesc_is_not_20); +COMPILE_ASSERT(offsetof(GetParamDesc, header) == 0, + OffsetOf_GetParamDesc_header_not_0); +COMPILE_ASSERT(offsetof(GetParamDesc, id) == 4, + OffsetOf_GetParamDesc_id_not_4); +COMPILE_ASSERT(offsetof(GetParamDesc, size) == 8, + OffsetOf_GetParamDesc_size_not_8); +COMPILE_ASSERT(offsetof(GetParamDesc, shared_memory) == 12, + OffsetOf_GetParamDesc_shared_memory_not_12); + +struct GetStreamCount { + typedef GetStreamCount ValueType; + static const CommandId kCmdId = command_buffer::kGetStreamCount; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + SetHeader(); + id = _id; + size = _size; + shared_memory.Init(shared_memory_id, shared_memory_offset); + } + + static void* Set(void* cmd, uint32 id, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + static_cast<ValueType*>(cmd)->Init(id, size, + shared_memory_id, shared_memory_offset); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; uint32 size; SharedMemory shared_memory; }; -struct GET_STREAM_DESC { - static const CommandId kCmdId = command_buffer::GET_STREAM_DESC; +COMPILE_ASSERT(sizeof(GetStreamCount) == 20, + Sizeof_GetStreamCount_is_not_20); +COMPILE_ASSERT(offsetof(GetStreamCount, header) == 0, + OffsetOf_GetStreamCount_header_not_0); +COMPILE_ASSERT(offsetof(GetStreamCount, id) == 4, + OffsetOf_GetStreamCount_id_not_4); +COMPILE_ASSERT(offsetof(GetStreamCount, size) == 8, + OffsetOf_GetStreamCount_size_not_8); +COMPILE_ASSERT(offsetof(GetStreamCount, shared_memory) == 12, + OffsetOf_GetStreamCount_shared_memory_not_12); + +struct GetStreamDesc { + typedef GetStreamDesc ValueType; + static const CommandId kCmdId = command_buffer::kGetStreamDesc; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _index, uint32 _size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + SetHeader(); + id = _id; + index = _index; + size = _size; + shared_memory.Init(shared_memory_id, shared_memory_offset); + } + + static void* Set(void* cmd, uint32 id, uint32 index, uint32 size, + uint32 shared_memory_id, uint32 shared_memory_offset) { + static_cast<ValueType*>(cmd)->Init(id, index, size, + shared_memory_id, shared_memory_offset); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; uint32 index; uint32 size; SharedMemory shared_memory; }; -struct DESTROY_TEXTURE { - static const CommandId kCmdId = command_buffer::DESTROY_TEXTURE; +COMPILE_ASSERT(sizeof(GetStreamDesc) == 24, Sizeof_GetStreamDesc_is_not_24); +COMPILE_ASSERT(offsetof(GetStreamDesc, header) == 0, + OffsetOf_GetStreamDesc_header_not_0); +COMPILE_ASSERT(offsetof(GetStreamDesc, id) ==4 , + OffsetOf_GetStreamDesc_id_not_4); +COMPILE_ASSERT(offsetof(GetStreamDesc, index) == 8, + OffsetOf_GetStreamDesc_index_not_8); +COMPILE_ASSERT(offsetof(GetStreamDesc, size) == 12, + OffsetOf_GetStreamDesc_size_not_12); +COMPILE_ASSERT(offsetof(GetStreamDesc, shared_memory) == 16, + OffsetOf_GetStreamDesc_shared_memory_not_16); + +struct DestroyTexture { + typedef DestroyTexture ValueType; + static const CommandId kCmdId = command_buffer::kDestroyTexture; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id) { + SetHeader(); + id = _id; + } + + static void* Set(void* cmd, uint32 id) { + static_cast<ValueType*>(cmd)->Init(id); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; }; -struct CREATE_TEXTURE_2D { - static const CommandId kCmdId = command_buffer::CREATE_TEXTURE_2D; - static const ArgFlags kArgFlags = kAtLeastN; +COMPILE_ASSERT(sizeof(DestroyTexture) == 8, Sizeof_DestroyTexture_is_not_8); +COMPILE_ASSERT(offsetof(DestroyTexture, header) == 0, + OffsetOf_DestroyTexture_header_not_0); +COMPILE_ASSERT(offsetof(DestroyTexture, id) == 4, + OffsetOf_DestroyTexture_id_not_4); + +struct CreateTexture2d { + typedef CreateTexture2d ValueType; + static const CommandId kCmdId = command_buffer::kCreateTexture2d; + static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _texture_id, + uint32 _width, uint32 _height, uint32 _levels, uint32 _format, + uint32 _enable_render_surfaces) { + SetHeader(); + texture_id = _texture_id; + fixme1 = + create_texture_2d_cmd::Width::MakeValue(_width) | + create_texture_2d_cmd::Height::MakeValue(_height); + fixme2 = + create_texture_2d_cmd::Levels::MakeValue(_levels) | + create_texture_2d_cmd::Format::MakeValue(_format) | + create_texture_2d_cmd::Flags::MakeValue(_enable_render_surfaces); + } + + static void* Set(void* cmd, uint32 texture_id, + uint32 width, uint32 height, uint32 levels, uint32 format, + uint32 enable_render_surfaces) { + static_cast<ValueType*>(cmd)->Init(texture_id, + width, height, levels, format, + enable_render_surfaces); + return NextCmdAddress<ValueType>(cmd); + } + // TODO(gman): fix this to not use obfusticated fields. + CommandHeader header; + uint32 texture_id; + uint32 fixme1; + uint32 fixme2; }; -struct CREATE_TEXTURE_3D { - static const CommandId kCmdId = command_buffer::CREATE_TEXTURE_3D; - static const ArgFlags kArgFlags = kAtLeastN; +COMPILE_ASSERT(sizeof(CreateTexture2d) == 16, + Sizeof_CreateTexture2d_is_not_16); +COMPILE_ASSERT(offsetof(CreateTexture2d, header) == 0, + OffsetOf_CreateTexture2d_header_not_0); +COMPILE_ASSERT(offsetof(CreateTexture2d, texture_id) == 4, + OffsetOf_CreateTexture2d_texture_id_not_4); +COMPILE_ASSERT(offsetof(CreateTexture2d, fixme1) == 8, + OffsetOf_CreateTexture2d_fixme1_not_8); +COMPILE_ASSERT(offsetof(CreateTexture2d, fixme2) == 12, + OffsetOf_CreateTexture2d_fixme2_not_12); + +struct CreateTexture3d { + typedef CreateTexture3d ValueType; + static const CommandId kCmdId = command_buffer::kCreateTexture3d; + static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _texture_id, + uint32 _width, uint32 _height, uint32 _depth, + uint32 _levels, uint32 _format, + uint32 _enable_render_surfaces) { + SetHeader(); + texture_id = _texture_id; + fixme1 = + create_texture_3d_cmd::Width::MakeValue(_width) | + create_texture_3d_cmd::Height::MakeValue(_height); + fixme2 = + create_texture_3d_cmd::Depth::MakeValue(_depth); + fixme3 = + create_texture_3d_cmd::Levels::MakeValue(_levels) | + create_texture_3d_cmd::Format::MakeValue(_format) | + create_texture_3d_cmd::Flags::MakeValue(_enable_render_surfaces); + } + + static void* Set(void* cmd, uint32 texture_id, + uint32 width, uint32 height, uint32 depth, + uint32 levels, uint32 format, + uint32 enable_render_surfaces) { + static_cast<ValueType*>(cmd)->Init(texture_id, + width, height, depth, + levels, format, + enable_render_surfaces); + return NextCmdAddress<ValueType>(cmd); + } + // TODO(gman): fix this to not use obfusticated fields. -}; + CommandHeader header; + uint32 texture_id; + uint32 fixme1; + uint32 fixme2; + uint32 fixme3; +}; + +COMPILE_ASSERT(sizeof(CreateTexture3d) == 20, + Sizeof_CreateTexture3d_is_not_20); +COMPILE_ASSERT(offsetof(CreateTexture3d, header) == 0, + OffsetOf_CreateTexture3d_header_not_0); +COMPILE_ASSERT(offsetof(CreateTexture3d, texture_id) == 4, + OffsetOf_CreateTexture3d_texture_id_not_4); +COMPILE_ASSERT(offsetof(CreateTexture3d, fixme1) == 8, + OffsetOf_CreateTexture3d_fixme1_not_8); +COMPILE_ASSERT(offsetof(CreateTexture3d, fixme2) == 12, + OffsetOf_CreateTexture3d_fixme2_not_12); +COMPILE_ASSERT(offsetof(CreateTexture3d, fixme3) == 16, + OffsetOf_CreateTexture3d_fixme3_not_16); + +struct CreateTextureCube { + typedef CreateTextureCube ValueType; + static const CommandId kCmdId = command_buffer::kCreateTextureCube; + static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _texture_id, + uint32 _edge_length, uint32 _levels, uint32 _format, + uint32 _enable_render_surfaces) { + SetHeader(); + texture_id = _texture_id; + edge_length = _edge_length; + fixme2 = + create_texture_2d_cmd::Levels::MakeValue(_levels) | + create_texture_2d_cmd::Format::MakeValue(_format) | + create_texture_2d_cmd::Flags::MakeValue(_enable_render_surfaces); + } + + static void* Set(void* cmd, uint32 texture_id, + uint32 edge_length, uint32 levels, uint32 format, + uint32 enable_render_surfaces) { + static_cast<ValueType*>(cmd)->Init(texture_id, + edge_length, levels, format, + enable_render_surfaces); + return NextCmdAddress<ValueType>(cmd); + } -struct CREATE_TEXTURE_CUBE { - static const CommandId kCmdId = command_buffer::CREATE_TEXTURE_CUBE; - static const ArgFlags kArgFlags = kAtLeastN; // TODO(gman): fix this to not use obfusticated fields. + CommandHeader header; + uint32 texture_id; + uint32 edge_length; + uint32 fixme2; }; -struct SET_TEXTURE_DATA { - static const CommandId kCmdId = command_buffer::SET_TEXTURE_DATA; - static const ArgFlags kArgFlags = kAtLeastN; +COMPILE_ASSERT(sizeof(CreateTextureCube) == 16, + Sizeof_CreateTextureCube_is_not_16); +COMPILE_ASSERT(offsetof(CreateTextureCube, header) == 0, + OffsetOf_CreateTextureCube_header_not_0); +COMPILE_ASSERT(offsetof(CreateTextureCube, texture_id) == 4, + OffsetOf_CreateTextureCube_texture_id_not_4); +COMPILE_ASSERT(offsetof(CreateTextureCube, edge_length) == 8, + OffsetOf_CreateTextureCube_edge_length_not_8); +COMPILE_ASSERT(offsetof(CreateTextureCube, fixme2) == 12, + OffsetOf_CreateTextureCube_fixme2_not_12); + +struct SetTextureData { + typedef SetTextureData ValueType; + static const CommandId kCmdId = command_buffer::kSetTextureData; + static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + uint32 _texture_id, + uint32 _x, + uint32 _y, + uint32 _z, + uint32 _width, + uint32 _height, + uint32 _depth, + uint32 _level, + uint32 _face, + uint32 _row_pitch, + uint32 _slice_pitch, + uint32 _size, + uint32 shared_memory_id, + uint32 shared_memory_offset) { + SetHeader(); + texture_id = _texture_id; + fixme1 = + set_texture_data_cmd::X::MakeValue(_x) | + set_texture_data_cmd::Y::MakeValue(_y); + fixme2 = + set_texture_data_cmd::Width::MakeValue(_width) | + set_texture_data_cmd::Height::MakeValue(_height); + fixme3 = + set_texture_data_cmd::Z::MakeValue(_z) | + set_texture_data_cmd::Depth::MakeValue(_depth); + fixme4 = + set_texture_data_cmd::Level::MakeValue(_level) | + set_texture_data_cmd::Face::MakeValue(_face); + row_pitch = _row_pitch; + slice_pitch = _slice_pitch; + size = _size; + shared_memory.Init(shared_memory_id, shared_memory_offset); + } + + static void* Set( + void* cmd, + uint32 texture_id, + uint32 x, + uint32 y, + uint32 z, + uint32 width, + uint32 height, + uint32 depth, + uint32 level, + uint32 face, + uint32 row_pitch, + uint32 slice_pitch, + uint32 size, + uint32 shared_memory_id, + uint32 shared_memory_offset) { + static_cast<ValueType*>(cmd)->Init( + texture_id, + x, + y, + z, + width, + height, + depth, + level, + face, + row_pitch, + slice_pitch, + size, + shared_memory_id, + shared_memory_offset); + return NextCmdAddress<ValueType>(cmd); + } + // TODO(gman): fix this to not use obfusticated fields. + CommandHeader header; + uint32 texture_id; + uint32 fixme1; + uint32 fixme2; + uint32 fixme3; + uint32 fixme4; + uint32 row_pitch; + uint32 slice_pitch; + uint32 size; + SharedMemory shared_memory; }; -struct SET_TEXTURE_DATA_IMMEDIATE { - static const CommandId kCmdId = command_buffer::SET_TEXTURE_DATA_IMMEDIATE; +COMPILE_ASSERT(sizeof(SetTextureData) == 44, + Sizeof_SetTextureData_is_not_44); +COMPILE_ASSERT(offsetof(SetTextureData, header) == 0, + OffsetOf_SetTextureData_header_not_0); +COMPILE_ASSERT(offsetof(SetTextureData, texture_id) == 4, + OffsetOf_SetTextureData_texture_id_not_4); +COMPILE_ASSERT(offsetof(SetTextureData, fixme1) == 8, + OffsetOf_SetTextureData_fixme1_not_8); +COMPILE_ASSERT(offsetof(SetTextureData, fixme2) == 12, + OffsetOf_SetTextureData_fixme2_not_12); +COMPILE_ASSERT(offsetof(SetTextureData, fixme3) == 16, + OffsetOf_SetTextureData_fixme3_not_16); +COMPILE_ASSERT(offsetof(SetTextureData, fixme4) == 20, + OffsetOf_SetTextureData_fixme4_not_20); +COMPILE_ASSERT(offsetof(SetTextureData, row_pitch) == 24, + OffsetOf_SetTextureData_row_pitch_not_24); +COMPILE_ASSERT(offsetof(SetTextureData, slice_pitch) == 28, + OffsetOf_SetTextureData_slice_pitch_not_28); +COMPILE_ASSERT(offsetof(SetTextureData, size) == 32, + OffsetOf_SetTextureData_size_not_32); +COMPILE_ASSERT(offsetof(SetTextureData, shared_memory) == 36, + OffsetOf_SetTextureData_shared_memory_not_36); + +struct SetTextureDataImmediate { + typedef SetTextureDataImmediate ValueType; + static const CommandId kCmdId = command_buffer::kSetTextureDataImmediate; static const ArgFlags kArgFlags = kAtLeastN; + + void SetHeader(uint32 size) { + header.SetCmdBySize<ValueType>(size); + } + + void Init( + uint32 _texture_id, + uint32 _x, + uint32 _y, + uint32 _z, + uint32 _width, + uint32 _height, + uint32 _depth, + uint32 _level, + uint32 _face, + uint32 _row_pitch, + uint32 _slice_pitch, + uint32 _size, + const void* data) { + SetHeader(_size); + texture_id = _texture_id; + fixme1 = + set_texture_data_cmd::X::MakeValue(_x) | + set_texture_data_cmd::Y::MakeValue(_y); + fixme2 = + set_texture_data_cmd::Width::MakeValue(_width) | + set_texture_data_cmd::Height::MakeValue(_height); + fixme3 = + set_texture_data_cmd::Z::MakeValue(_z) | + set_texture_data_cmd::Depth::MakeValue(_depth); + fixme4 = + set_texture_data_cmd::Level::MakeValue(_level) | + set_texture_data_cmd::Face::MakeValue(_face); + row_pitch = _row_pitch; + slice_pitch = _slice_pitch; + size = _size; + memcpy(ImmediateDataAddress(this), data, _size); + } + + static void* Set( + void* cmd, + uint32 texture_id, + uint32 x, + uint32 y, + uint32 z, + uint32 width, + uint32 height, + uint32 depth, + uint32 level, + uint32 face, + uint32 row_pitch, + uint32 slice_pitch, + uint32 size, + const void* data) { + static_cast<ValueType*>(cmd)->Init( + texture_id, + x, + y, + z, + width, + height, + depth, + level, + face, + row_pitch, + slice_pitch, + size, + data); + return NextImmediateCmdAddress<ValueType>(cmd, size); + } + // TODO(gman): fix this to not use obfusticated fields. + CommandHeader header; + uint32 texture_id; + uint32 fixme1; + uint32 fixme2; + uint32 fixme3; + uint32 fixme4; + uint32 row_pitch; + uint32 slice_pitch; + uint32 size; }; -struct GET_TEXTURE_DATA { - static const CommandId kCmdId = command_buffer::GET_TEXTURE_DATA; - static const ArgFlags kArgFlags = kAtLeastN; +COMPILE_ASSERT(sizeof(SetTextureDataImmediate) == 36, + Sizeof_SetTextureDataImmediate_is_not_36); +COMPILE_ASSERT(offsetof(SetTextureDataImmediate, header) == 0, + OffsetOf_SetTextureDataImmediate_header_not_0); +COMPILE_ASSERT(offsetof(SetTextureDataImmediate, texture_id) == 4, + OffsetOf_SetTextureDataImmediate_texture_id_not_4); +COMPILE_ASSERT(offsetof(SetTextureDataImmediate, fixme1) == 8, + OffsetOf_SetTextureDataImmediate_fixme1_not_8); +COMPILE_ASSERT(offsetof(SetTextureDataImmediate, fixme2) == 12, + OffsetOf_SetTextureDataImmediate_fixme2_not_12); +COMPILE_ASSERT(offsetof(SetTextureDataImmediate, fixme3) == 16, + OffsetOf_SetTextureDataImmediate_fixme3_not_16); +COMPILE_ASSERT(offsetof(SetTextureDataImmediate, fixme4) == 20, + OffsetOf_SetTextureDataImmediate_fixme4_not_20); +COMPILE_ASSERT(offsetof(SetTextureDataImmediate, row_pitch) == 24, + OffsetOf_SetTextureDataImmediate_row_pitch_not_24); +COMPILE_ASSERT(offsetof(SetTextureDataImmediate, slice_pitch) == 28, + OffsetOf_SetTextureDataImmediate_slice_pitch_not_28); +COMPILE_ASSERT(offsetof(SetTextureDataImmediate, size) == 32, + OffsetOf_SetTextureDataImmediate_size_not_32); + +struct GetTextureData { + typedef GetTextureData ValueType; + static const CommandId kCmdId = command_buffer::kGetTextureData; + static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + uint32 _texture_id, + uint32 _x, + uint32 _y, + uint32 _z, + uint32 _width, + uint32 _height, + uint32 _depth, + uint32 _level, + uint32 _face, + uint32 _row_pitch, + uint32 _slice_pitch, + uint32 _size, + uint32 shared_memory_id, + uint32 shared_memory_offset) { + SetHeader(); + texture_id = _texture_id; + fixme1 = + set_texture_data_cmd::X::MakeValue(_x) | + set_texture_data_cmd::Y::MakeValue(_y); + fixme2 = + set_texture_data_cmd::Width::MakeValue(_width) | + set_texture_data_cmd::Height::MakeValue(_height); + fixme3 = + set_texture_data_cmd::Z::MakeValue(_z) | + set_texture_data_cmd::Depth::MakeValue(_depth); + fixme4 = + set_texture_data_cmd::Level::MakeValue(_level) | + set_texture_data_cmd::Face::MakeValue(_face); + row_pitch = _row_pitch; + slice_pitch = _slice_pitch; + size = _size; + shared_memory.Init(shared_memory_id, shared_memory_offset); + } + + static void* Set( + void* cmd, + uint32 texture_id, + uint32 x, + uint32 y, + uint32 z, + uint32 width, + uint32 height, + uint32 depth, + uint32 level, + uint32 face, + uint32 row_pitch, + uint32 slice_pitch, + uint32 size, + uint32 shared_memory_id, + uint32 shared_memory_offset) { + static_cast<ValueType*>(cmd)->Init( + texture_id, + x, + y, + z, + width, + height, + depth, + level, + face, + row_pitch, + slice_pitch, + size, + shared_memory_id, + shared_memory_offset); + return NextCmdAddress<ValueType>(cmd); + } + // TODO(gman): fix this to not use obfusticated fields. + CommandHeader header; + uint32 texture_id; + uint32 fixme1; + uint32 fixme2; + uint32 fixme3; + uint32 fixme4; + uint32 row_pitch; + uint32 slice_pitch; + uint32 size; + SharedMemory shared_memory; }; -struct CREATE_SAMPLER { - static const CommandId kCmdId = command_buffer::CREATE_SAMPLER; +COMPILE_ASSERT(sizeof(GetTextureData) == 44, + Sizeof_GetTextureData_is_not_44); +COMPILE_ASSERT(offsetof(GetTextureData, header) == 0, + OffsetOf_GetTextureData_header_not_0); +COMPILE_ASSERT(offsetof(GetTextureData, texture_id) == 4, + OffsetOf_GetTextureData_texture_id_not_4); +COMPILE_ASSERT(offsetof(GetTextureData, fixme1) == 8, + OffsetOf_GetTextureData_fixme1_not_8); +COMPILE_ASSERT(offsetof(GetTextureData, fixme2) == 12, + OffsetOf_GetTextureData_fixme2_not_12); +COMPILE_ASSERT(offsetof(GetTextureData, fixme3) == 16, + OffsetOf_GetTextureData_fixme3_not_16); +COMPILE_ASSERT(offsetof(GetTextureData, fixme4) == 20, + OffsetOf_GetTextureData_fixme4_not_20); +COMPILE_ASSERT(offsetof(GetTextureData, row_pitch) == 24, + OffsetOf_GetTextureData_row_pitch_not_24); +COMPILE_ASSERT(offsetof(GetTextureData, slice_pitch) == 28, + OffsetOf_GetTextureData_slice_pitch_not_28); +COMPILE_ASSERT(offsetof(GetTextureData, size) == 32, + OffsetOf_GetTextureData_size_not_32); +COMPILE_ASSERT(offsetof(GetTextureData, shared_memory) == 36, + OffsetOf_GetTextureData_shared_memory_not_36); + +struct CreateSampler { + typedef CreateSampler ValueType; + static const CommandId kCmdId = command_buffer::kCreateSampler; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id) { + SetHeader(); + id = _id; + } + + static void* Set(void* cmd, uint32 id) { + static_cast<ValueType*>(cmd)->Init(id); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; }; -struct DESTROY_SAMPLER { - static const CommandId kCmdId = command_buffer::DESTROY_SAMPLER; +COMPILE_ASSERT(sizeof(CreateSampler) == 8, Sizeof_CreateSampler_is_not_8); +COMPILE_ASSERT(offsetof(CreateSampler, header) == 0, + OffsetOf_CreateSampler_header_not_0); +COMPILE_ASSERT(offsetof(CreateSampler, id) == 4, + OffsetOf_CreateSampler_id_not_4); + +struct DestroySampler { + typedef DestroySampler ValueType; + static const CommandId kCmdId = command_buffer::kDestroySampler; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id) { + SetHeader(); + id = _id; + } + + static void* Set(void* cmd, uint32 id) { + static_cast<ValueType*>(cmd)->Init(id); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; }; -struct SET_SAMPLER_STATES { - static const CommandId kCmdId = command_buffer::SET_SAMPLER_STATES; - static const ArgFlags kArgFlags = kAtLeastN; +COMPILE_ASSERT(sizeof(DestroySampler) == 8, Sizeof_DestroySampler_is_not_8); +COMPILE_ASSERT(offsetof(DestroySampler, header) == 0, + OffsetOf_DestroySampler_header_not_0); +COMPILE_ASSERT(offsetof(DestroySampler, id) == 4, + OffsetOf_DestroySampler_id_not_4); + +struct SetSamplerStates { + typedef SetSamplerStates ValueType; + static const CommandId kCmdId = command_buffer::kSetSamplerStates; + static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + uint32 _id, + uint32 _address_u_value, + uint32 _address_v_value, + uint32 _address_w_value, + uint32 _mag_filter_value, + uint32 _min_filter_value, + uint32 _mip_filter_value, + uint32 _max_anisotropy) { + SetHeader(); + id = _id; + fixme1 = + set_sampler_states::AddressingU::MakeValue(_address_u_value) | + set_sampler_states::AddressingV::MakeValue(_address_v_value) | + set_sampler_states::AddressingW::MakeValue(_address_w_value) | + set_sampler_states::MagFilter::MakeValue(_mag_filter_value) | + set_sampler_states::MinFilter::MakeValue(_min_filter_value) | + set_sampler_states::MipFilter::MakeValue(_mip_filter_value) | + set_sampler_states::MaxAnisotropy::MakeValue(_max_anisotropy); + } + + static void* Set(void* cmd, + uint32 id, + uint32 address_u_value, + uint32 address_v_value, + uint32 address_w_value, + uint32 mag_filter_value, + uint32 min_filter_value, + uint32 mip_filter_value, + uint32 max_anisotropy) { + static_cast<ValueType*>(cmd)->Init( + id, + address_u_value, + address_v_value, + address_w_value, + mag_filter_value, + min_filter_value, + mip_filter_value, + max_anisotropy); + return NextCmdAddress<ValueType>(cmd); + } + // TODO(gman): fix this to not use obfusticated fields. + CommandHeader header; + uint32 id; + uint32 fixme1; }; -struct SET_SAMPLER_BORDER_COLOR { - static const CommandId kCmdId = command_buffer::SET_SAMPLER_BORDER_COLOR; +COMPILE_ASSERT(sizeof(SetSamplerStates) == 12, + Sizeof_SetSamplerStates_is_not_12); +COMPILE_ASSERT(offsetof(SetSamplerStates, header) == 0, + OffsetOf_SetSamplerStates_header_not_0); +COMPILE_ASSERT(offsetof(SetSamplerStates, id) == 4, + OffsetOf_SetSamplerStates_id_not_4); +COMPILE_ASSERT(offsetof(SetSamplerStates, fixme1) == 8, + OffsetOf_SetSamplerStates_fixme1_not_8); + +struct SetSamplerBorderColor { + typedef SetSamplerBorderColor ValueType; + static const CommandId kCmdId = command_buffer::kSetSamplerBorderColor; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, + float _red, float _green, float _blue, float _alpha) { + SetHeader(); + id = _id; + red = _red; + green = _green; + blue = _blue; + alpha = _alpha; + } + + static void* Set(void* cmd, uint32 id, + float red, float green, float blue, float alpha) { + static_cast<ValueType*>(cmd)->Init(id, red, green, blue, alpha); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; float red; float blue; @@ -710,127 +2567,725 @@ struct SET_SAMPLER_BORDER_COLOR { float alpha; }; -struct SET_SAMPLER_TEXTURE { - static const CommandId kCmdId = command_buffer::SET_SAMPLER_TEXTURE; +COMPILE_ASSERT(sizeof(SetSamplerBorderColor) == 24, + Sizeof_SetSamplerBorderColor_is_not_24); +COMPILE_ASSERT(offsetof(SetSamplerBorderColor, header) == 0, + OffsetOf_SetSamplerBorderColor_header_not_0); +COMPILE_ASSERT(offsetof(SetSamplerBorderColor, id) == 4, + OffsetOf_SetSamplerBorderColor_id_not_4); +COMPILE_ASSERT(offsetof(SetSamplerBorderColor, red) == 8, + OffsetOf_SetSamplerBorderColor_red_not_8); +COMPILE_ASSERT(offsetof(SetSamplerBorderColor, blue) == 12, + OffsetOf_SetSamplerBorderColor_blue_not_12); +COMPILE_ASSERT(offsetof(SetSamplerBorderColor, green) == 16, + OffsetOf_SetSamplerBorderColor_green_not_16); +COMPILE_ASSERT(offsetof(SetSamplerBorderColor, alpha) == 20, + OffsetOf_SetSamplerBorderColor_alpha_not_20); + +struct SetSamplerTexture { + typedef SetSamplerTexture ValueType; + static const CommandId kCmdId = command_buffer::kSetSamplerTexture; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _texture_id) { + SetHeader(); + id = _id; + texture_id = _texture_id; + } + + static void* Set(void* cmd, uint32 id, uint32 texture_id) { + static_cast<ValueType*>(cmd)->Init(id, texture_id); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; uint32 texture_id; }; -struct SET_SCISSOR { - static const CommandId kCmdId = command_buffer::SET_SCISSOR; +COMPILE_ASSERT(sizeof(SetSamplerTexture) == 12, + Sizeof_SetSamplerTexture_is_not_12); +COMPILE_ASSERT(offsetof(SetSamplerTexture, header) == 0, + OffsetOf_SetSamplerTexture_header_not_0); +COMPILE_ASSERT(offsetof(SetSamplerTexture, id) == 4, + OffsetOf_SetSamplerTexture_id_not_4); +COMPILE_ASSERT(offsetof(SetSamplerTexture, texture_id) == 8, + OffsetOf_SetSamplerTexture_texture_id_not_8); + +struct SetScissor { + typedef SetScissor ValueType; + static const CommandId kCmdId = command_buffer::kSetScissor; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _x, + uint32 _y, + uint32 _width, + uint32 _height, + bool _enable) { + SetHeader(); + fixme0 = + set_scissor::X::MakeValue(_x) | + set_scissor::Y::MakeValue(_y) | + set_scissor::Enable::MakeValue(_enable ? 1 : 0); + fixme1 = + set_scissor::Width::MakeValue(_width) | + set_scissor::Height::MakeValue(_height); + } + + static void* Set( + void* cmd, + uint32 x, + uint32 y, + uint32 width, + uint32 height, + bool enable) { + static_cast<ValueType*>(cmd)->Init( + x, + y, + width, + height, + enable); + return NextCmdAddress<ValueType>(cmd); + } + // TODO(gman): fix this to not use obfusticated fields. + CommandHeader header; uint32 fixme0; uint32 fixme1; }; -struct SET_POLYGON_OFFSET { - static const CommandId kCmdId = command_buffer::SET_POLYGON_OFFSET; +COMPILE_ASSERT(sizeof(SetScissor) == 12, Sizeof_SetScissor_is_not_12); +COMPILE_ASSERT(offsetof(SetScissor, header) == 0, + OffsetOf_SetScissor_header_not_0); +COMPILE_ASSERT(offsetof(SetScissor, fixme0) == 4, + OffsetOf_SetScissor_fixme0_not_4); +COMPILE_ASSERT(offsetof(SetScissor, fixme1) == 8, + OffsetOf_SetScissor_fixme1_not_8); + +struct SetPolygonOffset { + typedef SetPolygonOffset ValueType; + static const CommandId kCmdId = command_buffer::kSetPolygonOffset; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(float _slope_factor, float _units) { + SetHeader(); + slope_factor = _slope_factor; + units = _units; + } + + static void* Set(void* cmd, float slope_factor, float units) { + static_cast<ValueType*>(cmd)->Init(slope_factor, units); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; float slope_factor; float units; }; -struct SET_POINT_LINE_RASTER { - static const CommandId kCmdId = command_buffer::SET_POINT_LINE_RASTER; +COMPILE_ASSERT(sizeof(SetPolygonOffset) == 12, + Sizeof_SetPolygonOffset_is_not_12); +COMPILE_ASSERT(offsetof(SetPolygonOffset, header) == 0, + OffsetOf_SetPolygonOffset_header_not_0); +COMPILE_ASSERT(offsetof(SetPolygonOffset, slope_factor) == 4, + OffsetOf_SetPolygonOffset_slope_factor_not_4); +COMPILE_ASSERT(offsetof(SetPolygonOffset, units) == 8, + OffsetOf_SetPolygonOffset_units_not_8); + +struct SetPointLineRaster { + typedef SetPointLineRaster ValueType; + static const CommandId kCmdId = command_buffer::kSetPointLineRaster; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(bool _line_smooth_enable, bool _point_sprite_enable, + float _point_size) { + SetHeader(); + fixme0 = + set_point_line_raster::LineSmoothEnable::MakeValue( + _line_smooth_enable ? 1 : 0) | + set_point_line_raster::PointSpriteEnable::MakeValue( + _point_sprite_enable ? 1 : 0); + point_size = _point_size; + } + + static void* Set(void* cmd, bool line_smooth_enable, bool point_sprite_enable, + float point_size) { + static_cast<ValueType*>(cmd)->Init(line_smooth_enable, point_sprite_enable, + point_size); + return NextCmdAddress<ValueType>(cmd); + } + // TODO(gman): fix this to not use obfusticated fields. + CommandHeader header; uint32 fixme0; float point_size; }; -struct SET_POLYGON_RASTER { - static const CommandId kCmdId = command_buffer::SET_POLYGON_RASTER; +COMPILE_ASSERT(sizeof(SetPointLineRaster) == 12, + Sizeof_SetPointLineRaster_is_not_12); +COMPILE_ASSERT(offsetof(SetPointLineRaster, header) == 0, + OffsetOf_SetPointLineRaster_header_not_0); +COMPILE_ASSERT(offsetof(SetPointLineRaster, fixme0) == 4, + OffsetOf_SetPointLineRaster_fixme0_not_4); +COMPILE_ASSERT(offsetof(SetPointLineRaster, point_size) == 8, + OffsetOf_SetPointLineRaster_point_size_not_8); + +struct SetPolygonRaster { + typedef SetPolygonRaster ValueType; + static const CommandId kCmdId = command_buffer::kSetPolygonRaster; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _fill_mode, uint32 _cull_mode) { + SetHeader(); + fixme0 = + set_polygon_raster::FillMode::MakeValue(_fill_mode) | + set_polygon_raster::CullMode::MakeValue(_cull_mode); + } + + static void* Set(void* cmd, uint32 fill_mode, uint32 cull_mode) { + static_cast<ValueType*>(cmd)->Init(fill_mode, cull_mode); + return NextCmdAddress<ValueType>(cmd); + } + // TODO(gman): fix this to not use obfusticated fields. + CommandHeader header; uint32 fixme0; }; -struct SET_ALPHA_TEST { - static const CommandId kCmdId = command_buffer::SET_ALPHA_TEST; +COMPILE_ASSERT(sizeof(SetPolygonRaster) == 8, + Sizeof_SetPolygonRaster_is_not_8); +COMPILE_ASSERT(offsetof(SetPolygonRaster, header) == 0, + OffsetOf_SetPolygonRaster_header_not_0); +COMPILE_ASSERT(offsetof(SetPolygonRaster, fixme0) == 4, + OffsetOf_SetPolygonRaster_fixme0_not_4); + +struct SetAlphaTest { + typedef SetAlphaTest ValueType; + static const CommandId kCmdId = command_buffer::kSetAlphaTest; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _func, bool _enable, float _value) { + SetHeader(); + fixme0 = + set_alpha_test::Func::MakeValue(_func) | + set_alpha_test::Enable::MakeValue(_enable ? 1 : 0); + value = _value; + } + + static void* Set(void* cmd, uint32 func, bool enable, float value) { + static_cast<ValueType*>(cmd)->Init(func, enable, value); + return NextCmdAddress<ValueType>(cmd); + } + // TODO(gman): fix this to not use obfusticated fields. + CommandHeader header; uint32 fixme0; float value; }; -struct SET_DEPTH_TEST { - static const CommandId kCmdId = command_buffer::SET_DEPTH_TEST; +COMPILE_ASSERT(sizeof(SetAlphaTest) == 12, Sizeof_SetAlphaTest_is_not_12); +COMPILE_ASSERT(offsetof(SetAlphaTest, header) == 0, + OffsetOf_SetAlphaTest_header_not_0); +COMPILE_ASSERT(offsetof(SetAlphaTest, fixme0) == 4, + OffsetOf_SetAlphaTest_fixme0_not_4); +COMPILE_ASSERT(offsetof(SetAlphaTest, value) == 8, + OffsetOf_SetAlphaTest_value_not_8); + +struct SetDepthTest { + typedef SetDepthTest ValueType; + static const CommandId kCmdId = command_buffer::kSetDepthTest; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _func, bool _write_enable, bool _enable) { + SetHeader(); + fixme0 = + set_depth_test::Func::MakeValue(_func) | + set_depth_test::WriteEnable::MakeValue(_write_enable ? 1 : 0) | + set_depth_test::Enable::MakeValue(_enable ? 1 : 0); + } + + static void* Set(void* cmd, uint32 func, bool write_enable, bool enable) { + static_cast<ValueType*>(cmd)->Init(func, write_enable, enable); + return NextCmdAddress<ValueType>(cmd); + } + // TODO(gman): fix this to not use obfusticated fields. + CommandHeader header; uint32 fixme0; }; -struct SET_STENCIL_TEST { - static const CommandId kCmdId = command_buffer::SET_STENCIL_TEST; - static const ArgFlags kArgFlags = kAtLeastN; +COMPILE_ASSERT(sizeof(SetDepthTest) == 8, Sizeof_SetDepthTest_is_not_8); +COMPILE_ASSERT(offsetof(SetDepthTest, header) == 0, + OffsetOf_SetDepthTest_header_not_0); +COMPILE_ASSERT(offsetof(SetDepthTest, fixme0) == 4, + OffsetOf_SetDepthTest_fixme0_not_4); + +struct SetStencilTest { + typedef SetStencilTest ValueType; + static const CommandId kCmdId = command_buffer::kSetStencilTest; + static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint8 _write_mask, + uint8 _compare_mask, + uint8 _reference_value, + bool _separate_ccw, + bool _enable, + uint8 _cw_func, + uint8 _cw_pass_op, + uint8 _cw_fail_op, + uint8 _cw_z_fail_op, + uint8 _ccw_func, + uint8 _ccw_pass_op, + uint8 _ccw_fail_op, + uint8 _ccw_z_fail_op) { + SetHeader(); + fixme0 = + set_stencil_test::WriteMask::MakeValue(_write_mask) | + set_stencil_test::CompareMask::MakeValue(_compare_mask) | + set_stencil_test::ReferenceValue::MakeValue(_reference_value) | + set_stencil_test::SeparateCCW::MakeValue(_separate_ccw ? 1 : 0) | + set_stencil_test::Enable::MakeValue(_enable ? 1 : 0); + fixme1 = + set_stencil_test::CWFunc::MakeValue(_cw_func) | + set_stencil_test::CWPassOp::MakeValue(_cw_pass_op) | + set_stencil_test::CWFailOp::MakeValue(_cw_fail_op) | + set_stencil_test::CWZFailOp::MakeValue(_cw_z_fail_op) | + set_stencil_test::CCWFunc::MakeValue(_ccw_func) | + set_stencil_test::CCWPassOp::MakeValue(_ccw_pass_op) | + set_stencil_test::CCWFailOp::MakeValue(_ccw_fail_op) | + set_stencil_test::CCWZFailOp::MakeValue(_ccw_z_fail_op); + } + + static void* Set( + void* cmd, + uint8 write_mask, + uint8 compare_mask, + uint8 reference_value, + bool separate_ccw, + bool enable, + uint8 cw_func, + uint8 cw_pass_op, + uint8 cw_fail_op, + uint8 cw_z_fail_op, + uint8 ccw_func, + uint8 ccw_pass_op, + uint8 ccw_fail_op, + uint8 ccw_z_fail_op) { + static_cast<ValueType*>(cmd)->Init( + write_mask, + compare_mask, + reference_value, + separate_ccw, + enable, + cw_func, + cw_pass_op, + cw_fail_op, + cw_z_fail_op, + ccw_func, + ccw_pass_op, + ccw_fail_op, + ccw_z_fail_op); + return NextCmdAddress<ValueType>(cmd); + } + // TODO(gman): fix this to not use obfusticated fields. + CommandHeader header; + uint32 fixme0; + uint32 fixme1; }; -struct SET_COLOR_WRITE { - static const CommandId kCmdId = command_buffer::SET_COLOR_WRITE; +COMPILE_ASSERT(sizeof(SetStencilTest) == 12, + Sizeof_SetStencilTest_is_not_12); +COMPILE_ASSERT(offsetof(SetStencilTest, header) == 0, + OffsetOf_SetStencilTest_header_not_0); +COMPILE_ASSERT(offsetof(SetStencilTest, fixme0) == 4, + OffsetOf_SetStencilTest_fixme0_not_4); +COMPILE_ASSERT(offsetof(SetStencilTest, fixme1) == 8, + OffsetOf_SetStencilTest_fixme1_not_8); + +struct SetColorWrite { + typedef SetColorWrite ValueType; + static const CommandId kCmdId = command_buffer::kSetColorWrite; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint8 _mask, bool _dither_enable) { + SetHeader(); + flags = + set_color_write::RedMask::MakeValue((_mask | 0x01) != 0 ? 1 : 0) | + set_color_write::GreenMask::MakeValue((_mask | 0x02) != 0 ? 1 : 0) | + set_color_write::BlueMask::MakeValue((_mask | 0x02) != 0 ? 1 : 0) | + set_color_write::AlphaMask::MakeValue((_mask | 0x02) != 0 ? 1 : 0) | + set_color_write::DitherEnable::MakeValue(_dither_enable ? 1 : 0); + } + + static void* Set(void* cmd, uint8 mask, bool dither_enable) { + static_cast<ValueType*>(cmd)->Init(mask, dither_enable); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 flags; }; -struct SET_BLENDING { - static const CommandId kCmdId = command_buffer::SET_BLENDING; - static const ArgFlags kArgFlags = kAtLeastN; +COMPILE_ASSERT(sizeof(SetColorWrite) == 8, Sizeof_SetColorWrite_is_not_8); +COMPILE_ASSERT(offsetof(SetColorWrite, header) == 0, + OffsetOf_SetColorWrite_header_not_0); +COMPILE_ASSERT(offsetof(SetColorWrite, flags) == 4, + OffsetOf_SetColorWrite_flags_not_4); + +struct SetBlending { + typedef SetBlending ValueType; + static const CommandId kCmdId = command_buffer::kSetBlending; + static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + uint8 _color_src_func, + uint8 _color_dst_func, + uint8 _color_eq, + uint8 _alpha_src_func, + uint8 _alpha_dst_func, + uint8 _alpha_eq, + bool _separate_alpha, + bool _enable) { + SetHeader(); + fixme0 = + set_blending::ColorSrcFunc::MakeValue(_color_src_func) | + set_blending::ColorDstFunc::MakeValue(_color_dst_func) | + set_blending::ColorEq::MakeValue(_color_eq) | + set_blending::AlphaSrcFunc::MakeValue(_alpha_src_func) | + set_blending::AlphaDstFunc::MakeValue(_alpha_dst_func) | + set_blending::AlphaEq::MakeValue(_alpha_eq) | + set_blending::SeparateAlpha::MakeValue(_separate_alpha ? 1 : 0) | + set_blending::Enable::MakeValue(_enable ? 1 : 0); + } + + static void* Set( + void* cmd, + uint8 color_src_func, + uint8 color_dst_func, + uint8 color_eq, + uint8 alpha_src_func, + uint8 alpha_dst_func, + uint8 alpha_eq, + bool separate_alpha, + bool enable) { + static_cast<ValueType*>(cmd)->Init( + color_src_func, + color_dst_func, + color_eq, + alpha_src_func, + alpha_dst_func, + alpha_eq, + separate_alpha, + enable); + return NextCmdAddress<ValueType>(cmd); + } + // TODO(gman): fix this to not use obfusticated fields. + CommandHeader header; + uint32 fixme0; }; -struct SET_BLENDING_COLOR { - static const CommandId kCmdId = command_buffer::SET_BLENDING_COLOR; +COMPILE_ASSERT(sizeof(SetBlending) == 8, Sizeof_SetBlending_is_not_8); +COMPILE_ASSERT(offsetof(SetBlending, header) == 0, + OffsetOf_SetBlending_header_not_0); +COMPILE_ASSERT(offsetof(SetBlending, fixme0) == 4, + OffsetOf_SetBlending_fixme0_not_4); + +struct SetBlendingColor { + typedef SetBlendingColor ValueType; + static const CommandId kCmdId = command_buffer::kSetBlendingColor; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(float _red, float _green, float _blue, float _alpha) { + SetHeader(); + red = _red; + green = _green; + blue = _blue; + alpha = _alpha; + } + + static void* Set(void* cmd, + float red, float green, float blue, float alpha) { + static_cast<ValueType*>(cmd)->Init(red, green, blue, alpha); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; float red; float blue; float green; float alpha; }; -struct CREATE_RENDER_SURFACE { - static const CommandId kCmdId = command_buffer::CREATE_RENDER_SURFACE; +COMPILE_ASSERT(sizeof(SetBlendingColor) == 20, + Sizeof_SetBlendingColor_is_not_20); +COMPILE_ASSERT(offsetof(SetBlendingColor, header) == 0, + OffsetOf_SetBlendingColor_header_not_0); +COMPILE_ASSERT(offsetof(SetBlendingColor, red) == 4, + OffsetOf_SetBlendingColor_red_not_4); +COMPILE_ASSERT(offsetof(SetBlendingColor, blue) == 8, + OffsetOf_SetBlendingColor_blue_not_8); +COMPILE_ASSERT(offsetof(SetBlendingColor, green) == 12, + OffsetOf_SetBlendingColor_green_not_12); +COMPILE_ASSERT(offsetof(SetBlendingColor, alpha) == 16, + OffsetOf_SetBlendingColor_alpha_not_16); + +struct CreateRenderSurface { + typedef CreateRenderSurface ValueType; + static const CommandId kCmdId = command_buffer::kCreateRenderSurface; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _texture_id, uint32 _width, uint32 _height, + uint32 _level, uint32 _side) { + SetHeader(); + id = _id; + // TODO(gman): Why does this need a width and height. It's inherited from + // the texture isn't it? + fixme1 = + create_render_surface_cmd::Width::MakeValue(_width) | + create_render_surface_cmd::Height::MakeValue(_height); + fixme2 = + create_render_surface_cmd::Levels::MakeValue(_level) | + create_render_surface_cmd::Side::MakeValue(_side); + texture_id = _texture_id; + } + + static void* Set(void* cmd, uint32 id, uint32 texture_id, + uint32 width, uint32 height, + uint32 level, uint32 side) { + static_cast<ValueType*>(cmd)->Init(id, texture_id, width, height, + level, side); + return NextCmdAddress<ValueType>(cmd); + } + // TODO(gman): fix this to not use obfusticated fields. + CommandHeader header; uint32 id; uint32 fixme1; uint32 fixme2; uint32 texture_id; }; -struct DESTROY_RENDER_SURFACE { - static const CommandId kCmdId = command_buffer::DESTROY_RENDER_SURFACE; +COMPILE_ASSERT(sizeof(CreateRenderSurface) == 20, + Sizeof_CreateRenderSurface_is_not_20); +COMPILE_ASSERT(offsetof(CreateRenderSurface, header) == 0, + OffsetOf_CreateRenderSurface_header_not_0); +COMPILE_ASSERT(offsetof(CreateRenderSurface, id) == 4, + OffsetOf_CreateRenderSurface_id_not_4); +COMPILE_ASSERT(offsetof(CreateRenderSurface, fixme1) == 8, + OffsetOf_CreateRenderSurface_fixme1_not_8); +COMPILE_ASSERT(offsetof(CreateRenderSurface, fixme2) == 12, + OffsetOf_CreateRenderSurface_fixme2_not_12); +COMPILE_ASSERT(offsetof(CreateRenderSurface, texture_id) == 16, + OffsetOf_CreateRenderSurface_texture_id_not_16); + +struct DestroyRenderSurface { + typedef DestroyRenderSurface ValueType; + static const CommandId kCmdId = command_buffer::kDestroyRenderSurface; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id) { + SetHeader(); + id = _id; + } + + static void* Set(void* cmd, uint32 id) { + static_cast<ValueType*>(cmd)->Init(id); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; }; -struct CREATE_DEPTH_SURFACE { - static const CommandId kCmdId = command_buffer::CREATE_DEPTH_SURFACE; +COMPILE_ASSERT(sizeof(DestroyRenderSurface) == 8, + Sizeof_DestroyRenderSurface_is_not_8); +COMPILE_ASSERT(offsetof(DestroyRenderSurface, header) == 0, + OffsetOf_DestroyRenderSurface_header_not_0); +COMPILE_ASSERT(offsetof(DestroyRenderSurface, id) == 4, + OffsetOf_DestroyRenderSurface_id_not_4); + +struct CreateDepthSurface { + typedef CreateDepthSurface ValueType; + static const CommandId kCmdId = command_buffer::kCreateDepthSurface; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id, uint32 _width, uint32 _height) { + SetHeader(); + id = _id; + fixme1 = + create_depth_surface_cmd::Width::MakeValue(_width) | + create_depth_surface_cmd::Height::MakeValue(_height); + } + + static void* Set(void* cmd, uint32 id, uint32 width, uint32 height) { + static_cast<ValueType*>(cmd)->Init(id, width, height); + return NextCmdAddress<ValueType>(cmd); + } + // TODO(gman): fix this to not use obfusticated fields. + CommandHeader header; uint32 id; uint32 fixme1; }; -struct DESTROY_DEPTH_SURFACE { - static const CommandId kCmdId = command_buffer::DESTROY_DEPTH_SURFACE; +COMPILE_ASSERT(sizeof(CreateDepthSurface) == 12, + Sizeof_CreateDepthSurface_is_not_12); +COMPILE_ASSERT(offsetof(CreateDepthSurface, header) == 0, + OffsetOf_CreateDepthSurface_header_not_0); +COMPILE_ASSERT(offsetof(CreateDepthSurface, id) == 4, + OffsetOf_CreateDepthSurface_id_not_4); +COMPILE_ASSERT(offsetof(CreateDepthSurface, fixme1) == 8, + OffsetOf_CreateDepthSurface_fixme1_not_8); + +struct DestroyDepthSurface { + typedef DestroyDepthSurface ValueType; + static const CommandId kCmdId = command_buffer::kDestroyDepthSurface; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _id) { + SetHeader(); + id = _id; + } + + static void* Set(void* cmd, uint32 id) { + static_cast<ValueType*>(cmd)->Init(id); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 id; }; -struct SET_RENDER_SURFACE { - static const CommandId kCmdId = command_buffer::SET_RENDER_SURFACE; +COMPILE_ASSERT(sizeof(DestroyDepthSurface) == 8, + Sizeof_DestroyDepthSurface_is_not_8); +COMPILE_ASSERT(offsetof(DestroyDepthSurface, header) == 0, + OffsetOf_DestroyDepthSurface_header_not_0); +COMPILE_ASSERT(offsetof(DestroyDepthSurface, id) == 4, + OffsetOf_DestroyDepthSurface_id_not_4); + +struct SetRenderSurface { + typedef SetRenderSurface ValueType; + static const CommandId kCmdId = command_buffer::kSetRenderSurface; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _render_surface_id, uint32 _depth_surface_id) { + SetHeader(); + render_surface_id = _render_surface_id; + depth_surface_id = _depth_surface_id; + } + + static void* Set(void* cmd, + uint32 render_surface_id, uint32 depth_surface_id) { + static_cast<ValueType*>(cmd)->Init(render_surface_id, depth_surface_id); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; uint32 render_surface_id; uint32 depth_surface_id; }; -struct SET_BACK_SURFACES { - static const CommandId kCmdId = command_buffer::SET_BACK_SURFACES; +COMPILE_ASSERT(sizeof(SetRenderSurface) == 12, + Sizeof_SetRenderSurface_is_not_12); +COMPILE_ASSERT(offsetof(SetRenderSurface, header) == 0, + OffsetOf_SetRenderSurface_header_not_0); +COMPILE_ASSERT(offsetof(SetRenderSurface, render_surface_id) == 4, + OffsetOf_SetRenderSurface_render_surface_id_not_4); +COMPILE_ASSERT(offsetof(SetRenderSurface, depth_surface_id) == 8, + OffsetOf_SetRenderSurface_depth_surface_id_not_8); + +struct SetBackSurfaces { + typedef SetBackSurfaces ValueType; + static const CommandId kCmdId = command_buffer::kSetBackSurfaces; static const ArgFlags kArgFlags = kFixed; + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init() { + SetHeader(); + } + + static void* Set(void* cmd) { + static_cast<ValueType*>(cmd)->Init(); + return NextCmdAddress<ValueType>(cmd); + } + + CommandHeader header; }; +COMPILE_ASSERT(sizeof(SetBackSurfaces) == 4, + Sizeof_SetBackSurfaces_is_not_4); +COMPILE_ASSERT(offsetof(SetBackSurfaces, header) == 0, + OffsetOf_SetBackSurfaces_header_not_0); + O3D_POP_STRUCTURE_PACKING; } // namespace cmd diff --git a/o3d/command_buffer/common/cross/gapi_interface.h b/o3d/command_buffer/common/cross/gapi_interface.h index fdf4b5e..1766428 100644 --- a/o3d/command_buffer/common/cross/gapi_interface.h +++ b/o3d/command_buffer/common/cross/gapi_interface.h @@ -180,8 +180,8 @@ class GAPIInterface { // size: the size of the vertex buffer, in bytes. // flags: the vertex buffer flags, as a combination of vertex_buffer::Flags // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError CreateVertexBuffer(ResourceID id, unsigned int size, unsigned int flags) = 0; @@ -190,8 +190,8 @@ class GAPIInterface { // Parameters: // id: the resource ID of the vertex buffer. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid vertex buffer - // ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if an invalid vertex buffer + // ID was passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError DestroyVertexBuffer(ResourceID id) = 0; // Sets data into a vertex buffer. @@ -201,9 +201,9 @@ class GAPIInterface { // size: the size of the data. // data: the source data. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments were + // BufferSyncInterface::kParseInvalidArguments if invalid arguments were // passed: invalid resource ID, or offset or size out of range. - // BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseNoError otherwise. virtual ParseError SetVertexBufferData(ResourceID id, unsigned int offset, unsigned int size, @@ -216,9 +216,9 @@ class GAPIInterface { // size: the size of the data. // data: the destination buffer. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments were + // BufferSyncInterface::kParseInvalidArguments if invalid arguments were // passed: invalid resource ID, or offset or size out of range. - // BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseNoError otherwise. virtual ParseError GetVertexBufferData(ResourceID id, unsigned int offset, unsigned int size, @@ -232,8 +232,8 @@ class GAPIInterface { // Note that indices are 16 bits unless the index_buffer::INDEX_32BIT // flag is specified. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError CreateIndexBuffer(ResourceID id, unsigned int size, unsigned int flags) = 0; @@ -242,8 +242,8 @@ class GAPIInterface { // Parameters: // id: the resource ID of the index buffer. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid index buffer - // ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if an invalid index buffer + // ID was passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError DestroyIndexBuffer(ResourceID id) = 0; // Sets data into an index buffer. @@ -253,9 +253,9 @@ class GAPIInterface { // size: the size of the data. // data: the source data. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments were + // BufferSyncInterface::kParseInvalidArguments if invalid arguments were // passed: invalid resource ID, or offset or size out of range. - // BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseNoError otherwise. virtual ParseError SetIndexBufferData(ResourceID id, unsigned int offset, unsigned int size, @@ -268,9 +268,9 @@ class GAPIInterface { // size: the size of the data. // data: the destination buffer. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments were + // BufferSyncInterface::kParseInvalidArguments if invalid arguments were // passed: invalid resource ID, or offset or size out of range. - // BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseNoError otherwise. virtual ParseError GetIndexBufferData(ResourceID id, unsigned int offset, unsigned int size, @@ -282,8 +282,8 @@ class GAPIInterface { // id: the resource ID of the vertex struct. // input_count: the number of input vertex attributes. // returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError CreateVertexStruct(ResourceID id, unsigned int input_count) = 0; @@ -291,8 +291,8 @@ class GAPIInterface { // Parameters: // id: the resource ID of the vertex struct. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid vertex struct - // ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if an invalid vertex struct + // ID was passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError DestroyVertexStruct(ResourceID id) = 0; // Sets an input into a vertex struct. @@ -307,8 +307,8 @@ class GAPIInterface { // semantic: the semantic of the input. // semantic_index: the semantic index of the input. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError SetVertexInput(ResourceID vertex_struct_id, unsigned int input_index, ResourceID vertex_buffer_id, @@ -322,8 +322,8 @@ class GAPIInterface { // Parameters: // id: the resource ID of the vertex struct. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed (invalid vertex struct), BufferSyncInterface::PARSE_NO_ERROR + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed (invalid vertex struct), BufferSyncInterface::kParseNoError // otherwise. virtual ParseError SetVertexStruct(ResourceID id) = 0; @@ -333,8 +333,8 @@ class GAPIInterface { // first: the index of the first vertex. // count: the number of primitives to draw. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError Draw(PrimitiveType primitive_type, unsigned int first, unsigned int count) = 0; @@ -349,8 +349,8 @@ class GAPIInterface { // min_index: the lowest index being drawn. // max_index: the highest index being drawn. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError DrawIndexed(PrimitiveType primitive_type, ResourceID index_buffer_id, unsigned int first, @@ -364,9 +364,9 @@ class GAPIInterface { // size: the size of data. // data: the source code for the effect. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are // passed or the effect failed to compile, - // BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseNoError otherwise. virtual ParseError CreateEffect(ResourceID id, unsigned int size, const void *data) = 0; @@ -375,16 +375,16 @@ class GAPIInterface { // Parameters: // id: the resource ID of the effect. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid effect ID - // was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if an invalid effect ID + // was passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError DestroyEffect(ResourceID id) = 0; // Sets the active effect for drawing. // Parameters: // id: the resource ID of the effect. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError SetEffect(ResourceID id) = 0; // Gets the number of parameters in an effect, returning it in a memory @@ -395,8 +395,8 @@ class GAPIInterface { // Uint32). // data: the buffer receiving the data. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError GetParamCount(ResourceID id, unsigned int size, void *data) = 0; @@ -409,9 +409,9 @@ class GAPIInterface { // the effect source. // index: the index of the parameter. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are // passed, such as invalid effect ID, unmatching data type or invalid - // index, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // index, BufferSyncInterface::kParseNoError otherwise. virtual ParseError CreateParam(ResourceID param_id, ResourceID effect_id, unsigned int index) = 0; @@ -426,9 +426,9 @@ class GAPIInterface { // name: the parameter name, as an array of char. Doesn't have to be // nul-terminated (though nul will terminate the string). // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are // passed, such as invalid effect ID, unmatching data type or no parameter - // was found with this name, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // was found with this name, BufferSyncInterface::kParseNoError otherwise. virtual ParseError CreateParamByName(ResourceID param_id, ResourceID effect_id, unsigned int size, @@ -438,8 +438,8 @@ class GAPIInterface { // Parameters: // id: the resource ID of the parameter. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid parameter ID - // was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if an invalid parameter ID + // was passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError DestroyParam(ResourceID id) = 0; // Sets the effect parameter data. @@ -448,9 +448,9 @@ class GAPIInterface { // size: the size of the data. Must be at least the size of the parameter // as described by its type. // data: the parameter data. - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are // passed, such as invalid parameter ID, or unmatching data size, - // BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseNoError otherwise. virtual ParseError SetParamData(ResourceID id, unsigned int size, const void *data) = 0; @@ -470,10 +470,10 @@ class GAPIInterface { // description. Must be at least sizeof(effect_param::Desc). // data: the memory buffer. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are // passed, such as invalid parameter ID, or unsufficient data size, - // BufferSyncInterface::PARSE_NO_ERROR otherwise. Note that - // BufferSyncInterface::PARSE_NO_ERROR will be returned if the structure + // BufferSyncInterface::kParseNoError otherwise. Note that + // BufferSyncInterface::kParseNoError will be returned if the structure // itself fits, not necessarily the names. To make sure all the information // is available, the caller should compare the returned size member of the // effect_param::Desc structure to the size parameter passed in. @@ -489,8 +489,8 @@ class GAPIInterface { // Uint32). // data: the buffer receiving the data. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError GetStreamCount(ResourceID id, unsigned int size, void *data) = 0; @@ -520,8 +520,8 @@ class GAPIInterface { // flags: the texture flags, as a combination of texture::Flags. // enable_render_surfaces: bool for whether to enable render surfaces // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError CreateTexture2D(ResourceID id, unsigned int width, unsigned int height, @@ -542,8 +542,8 @@ class GAPIInterface { // flags: the texture flags, as a combination of texture::Flags. // enable_render_surfaces: bool for whether to enable render surfaces // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError CreateTexture3D(ResourceID id, unsigned int width, unsigned int height, @@ -563,8 +563,8 @@ class GAPIInterface { // flags: the texture flags, as a combination of texture::Flags. // enable_render_surfaces: bool for whether to enable render surfaces // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError CreateTextureCube(ResourceID id, unsigned int side, unsigned int levels, @@ -599,9 +599,9 @@ class GAPIInterface { // size: the size of the data. // data: the texel data. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are // passed, for example invalid size, or out-of-bounds rectangle/volume, - // BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseNoError otherwise. virtual ParseError SetTextureData(ResourceID id, unsigned int x, unsigned int y, @@ -643,9 +643,9 @@ class GAPIInterface { // size: the size of the data. // data: the destination buffer. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are // passed, for example invalid size, or out-of-bounds rectangle/volume, - // BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseNoError otherwise. virtual ParseError GetTextureData(ResourceID id, unsigned int x, unsigned int y, @@ -664,23 +664,23 @@ class GAPIInterface { // Parameters: // id: the resource ID of the texture. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid texture - // resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if an invalid texture + // resource ID was passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError DestroyTexture(ResourceID id) = 0; // Creates a sampler resource. // Parameters: // id: the resource ID of the sampler. // Returns: - // BufferSyncInterface::PARSE_NO_ERROR. + // BufferSyncInterface::kParseNoError. virtual ParseError CreateSampler(ResourceID id) = 0; // Destroys a sampler resource. // Parameters: // id: the resource ID of the sampler. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid sampler - // resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if an invalid sampler + // resource ID was passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError DestroySampler(ResourceID id) = 0; // Sets the states in a sampler resource. @@ -694,8 +694,8 @@ class GAPIInterface { // mip_filter: the filtering mode for mip-map interpolation textures. // max_anisotropy: the maximum anisotropy. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid sampler - // resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if an invalid sampler + // resource ID was passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError SetSamplerStates(ResourceID id, sampler::AddressingMode addressing_u, sampler::AddressingMode addressing_v, @@ -710,8 +710,8 @@ class GAPIInterface { // id: the resource ID of the sampler. // color: the border color. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid sampler - // resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if an invalid sampler + // resource ID was passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError SetSamplerBorderColor(ResourceID id, const RGBA &color) = 0; @@ -720,8 +720,8 @@ class GAPIInterface { // id: the resource ID of the sampler. // texture_id: the resource id of the texture. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid sampler - // resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if an invalid sampler + // resource ID was passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError SetSamplerTexture(ResourceID id, ResourceID texture_id) = 0; @@ -860,8 +860,8 @@ class GAPIInterface { // height: the texture height. Must be positive. // texture_id: the resource id of the texture. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError CreateRenderSurface(ResourceID id, unsigned int width, unsigned int height,
@@ -873,9 +873,9 @@ class GAPIInterface { // Parameters: // id: the resource ID of the render surface. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid render + // BufferSyncInterface::kParseInvalidArguments if an invalid render // surface - // resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // resource ID was passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError DestroyRenderSurface(ResourceID id) = 0; // Creates a depth stencil surface resource. @@ -884,8 +884,8 @@ class GAPIInterface { // width: the texture width. Must be positive. // height: the texture height. Must be positive. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError CreateDepthSurface(ResourceID id, unsigned int width, unsigned int height) = 0; @@ -894,9 +894,9 @@ class GAPIInterface { // Parameters: // id: the resource ID of the depth stencil surface. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid render + // BufferSyncInterface::kParseInvalidArguments if an invalid render // surface - // resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // resource ID was passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError DestroyDepthSurface(ResourceID id) = 0; // Switches the render surface and depth stencil surface to those @@ -905,8 +905,8 @@ class GAPIInterface { // render_surface_id: the resource ID of the render surface. // depth_stencil_id: the resource ID of the render depth stencil surface. // Returns: - // BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are - // passed, BufferSyncInterface::PARSE_NO_ERROR otherwise. + // BufferSyncInterface::kParseInvalidArguments if invalid arguments are + // passed, BufferSyncInterface::kParseNoError otherwise. virtual ParseError SetRenderSurface(ResourceID render_surface_id, ResourceID depth_stencil_id) = 0; diff --git a/o3d/command_buffer/common/cross/resource.h b/o3d/command_buffer/common/cross/resource.h index 5557d67..408f8ea 100644 --- a/o3d/command_buffer/common/cross/resource.h +++ b/o3d/command_buffer/common/cross/resource.h @@ -46,6 +46,7 @@ namespace o3d { namespace command_buffer { // A resource ID, key to the resource maps. +// TODO(gman): Shouldn't this be a uint32? typedef unsigned int ResourceID; // Invalid resource ID. static const ResourceID kInvalidResource = 0xffffffffU; diff --git a/o3d/command_buffer/samples/bubble/bubble_module.cc b/o3d/command_buffer/samples/bubble/bubble_module.cc index 42eae04..b24a3d1 100644 --- a/o3d/command_buffer/samples/bubble/bubble_module.cc +++ b/o3d/command_buffer/samples/bubble/bubble_module.cc @@ -38,7 +38,7 @@ #ifdef __native_demo__ #include <sys/nacl_syscalls.h> #else -#include "native_client/service_runtime/nrd_xfer_lib/nrd_all_modules.h" +#include "native_client/src/shared/imc/nacl_imc.h" #endif #include "command_buffer/common/cross/gapi_interface.h" #include "command_buffer/common/cross/rpc_imc.h" @@ -50,8 +50,7 @@ #include "command_buffer/samples/bubble/perlin_noise.h" #include "third_party/vectormath/files/vectormathlibrary/include/vectormath/scalar/cpp/vectormath_aos.h" // NOLINT -#include "native_client/intermodule_comm/nacl_imc.h" -#include "native_client/tools/npapi_runtime/nacl_npapi.h" +#include "native_client/src/shared/npruntime/nacl_npapi.h" // Cube map data is hard-coded in cubemap.cc as a byte array. // Format is 64x64xBRGA, D3D face ordering (+X, -X, +Y, -Y, +Z, -Z). @@ -68,7 +67,7 @@ const unsigned int kCubeMapFaceSize = kCubeMapWidth * kCubeMapHeight * 4; HELPER->Finish(); \ BufferSyncInterface::ParseError error = \ HELPER->interface()->GetParseError(); \ - if (error != BufferSyncInterface::PARSE_NO_ERROR) { \ + if (error != BufferSyncInterface::kParseNoError) { \ printf("CMD error %d at %s:%d\n", error, __FILE__, __LINE__); \ } \ } while (false) @@ -114,15 +113,8 @@ void ClearCmd(CommandBufferHelper *cmd_buffer, const RGBA &color, float depth, unsigned int stencil) { - CommandBufferEntry args[7]; - args[0].value_uint32 = buffers; - args[1].value_float = color.red; - args[2].value_float = color.green; - args[3].value_float = color.blue; - args[4].value_float = color.alpha; - args[5].value_float = depth; - args[6].value_uint32 = stencil; - cmd_buffer->AddCommand(command_buffer::CLEAR, 7, args); + cmd_buffer->Clear(buffers, color.red, color.green, color.blue, color.alpha, + depth, stencil); CHECK_ERROR(cmd_buffer); } @@ -138,14 +130,7 @@ void SetViewportCmd(CommandBufferHelper *cmd_buffer, unsigned int height, float z_near, float z_far) { - CommandBufferEntry args[6]; - args[0].value_uint32 = x; - args[1].value_uint32 = y; - args[2].value_uint32 = width; - args[3].value_uint32 = height; - args[4].value_float = z_near; - args[5].value_float = z_far; - cmd_buffer->AddCommand(command_buffer::SET_VIEWPORT, 6, args); + cmd_buffer->SetViewport(x, y, width, height, z_near, z_far); CHECK_ERROR(cmd_buffer); } @@ -311,9 +296,10 @@ void MakeNoiseTexture(unsigned int width, // Gets current time in microseconds. uint64_t GetTimeUsec() { - struct timeval tv; - gettimeofday(&tv, NULL); - return tv.tv_sec * 1000000ULL + tv.tv_usec; + return 0ULL; +// struct timeval tv; +// gettimeofday(&tv, NULL); +// return tv.tv_sec * 1000000ULL + tv.tv_usec; } class BubbleDemo { @@ -483,16 +469,11 @@ void BubbleDemo::Initialize() { ClearCmd(helper_.get(), GAPIInterface::COLOR | GAPIInterface::DEPTH, color, 1.f, 0); - // AddCommand copies the args, so it is safe to re-use args across various - // calls. - // 20 is the largest command we use (SET_PARAM_DATA_IMMEDIATE for matrices). - CommandBufferEntry args[20]; - // Create geometry arrays and structures args[0].value_uint32 = vertex_buffer_id_; args[1].value_uint32 = kVertexBufferSize; // size args[2].value_uint32 = 0; // flags - helper_->AddCommand(CREATE_VERTEX_BUFFER, 3, args); + helper_->AddCommand(CreateVertexBuffer, 3, args); CHECK_ERROR(helper_); args[0].value_uint32 = vertex_buffer_id_; @@ -500,13 +481,13 @@ void BubbleDemo::Initialize() { args[2].value_uint32 = kVertexBufferSize; // size args[3].value_uint32 = shm_id_; // shm args[4].value_uint32 = allocator_->GetOffset(vertices_); // offset in shm - helper_->AddCommand(SET_VERTEX_BUFFER_DATA, 5, args); + helper_->AddCommand(SetVertexBufferData, 5, args); CHECK_ERROR(helper_); args[0].value_uint32 = index_buffer_id_; args[1].value_uint32 = kIndexBufferSize; // size args[2].value_uint32 = index_buffer::INDEX_32BIT; // flags - helper_->AddCommand(CREATE_INDEX_BUFFER, 3, args); + helper_->AddCommand(CreateIndexBuffer, 3, args); CHECK_ERROR(helper_); args[0].value_uint32 = index_buffer_id_; @@ -514,12 +495,12 @@ void BubbleDemo::Initialize() { args[2].value_uint32 = kIndexBufferSize; // size args[3].value_uint32 = shm_id_; // shm args[4].value_uint32 = allocator_->GetOffset(indices_); // offset in shm - helper_->AddCommand(SET_INDEX_BUFFER_DATA, 5, args); + helper_->AddCommand(SetIndexBufferData, 5, args); CHECK_ERROR(helper_); args[0].value_uint32 = vertex_struct_id_; args[1].value_uint32 = 3; // input count - helper_->AddCommand(CREATE_VERTEX_STRUCT, 2, args); + helper_->AddCommand(CreateVertexStruct, 2, args); CHECK_ERROR(helper_); // Set POSITION input stream @@ -532,7 +513,7 @@ void BubbleDemo::Initialize() { set_vertex_input_cmd::Type::MakeValue(vertex_struct::FLOAT3) | set_vertex_input_cmd::Semantic::MakeValue(vertex_struct::POSITION) | set_vertex_input_cmd::SemanticIndex::MakeValue(0); - helper_->AddCommand(SET_VERTEX_INPUT, 5, args); + helper_->AddCommand(SetVertexInput, 5, args); CHECK_ERROR(helper_); // Set NORMAL input stream @@ -543,7 +524,7 @@ void BubbleDemo::Initialize() { set_vertex_input_cmd::Type::MakeValue(vertex_struct::FLOAT3) | set_vertex_input_cmd::Semantic::MakeValue(vertex_struct::NORMAL) | set_vertex_input_cmd::SemanticIndex::MakeValue(0); - helper_->AddCommand(SET_VERTEX_INPUT, 5, args); + helper_->AddCommand(SetVertexInput, 5, args); CHECK_ERROR(helper_); // Set TEXCOORD0 input stream @@ -554,7 +535,7 @@ void BubbleDemo::Initialize() { set_vertex_input_cmd::Type::MakeValue(vertex_struct::FLOAT2) | set_vertex_input_cmd::Semantic::MakeValue(vertex_struct::TEX_COORD) | set_vertex_input_cmd::SemanticIndex::MakeValue(0); - helper_->AddCommand(SET_VERTEX_INPUT, 5, args); + helper_->AddCommand(SetVertexInput, 5, args); CHECK_ERROR(helper_); // Create a 2D texture. @@ -566,7 +547,7 @@ void BubbleDemo::Initialize() { create_texture_2d_cmd::Levels::MakeValue(0) | create_texture_2d_cmd::Format::MakeValue(texture::ARGB8) | create_texture_2d_cmd::Flags::MakeValue(0); - helper_->AddCommand(CREATE_TEXTURE_2D, 3, args); + helper_->AddCommand(CreateTexture2d, 3, args); CHECK_ERROR(helper_); args[0].value_uint32 = noise_texture_id_; @@ -585,16 +566,16 @@ void BubbleDemo::Initialize() { args[7].value_uint32 = kTexSize; // size args[8].value_uint32 = shm_id_; args[9].value_uint32 = allocator_->GetOffset(noise_texture_); - helper_->AddCommand(SET_TEXTURE_DATA, 10, args); + helper_->AddCommand(SetTextureData, 10, args); CHECK_ERROR(helper_); args[0].value_uint32 = noise_sampler_id_; - helper_->AddCommand(CREATE_SAMPLER, 1, args); + helper_->AddCommand(CreateSampler, 1, args); CHECK_ERROR(helper_); args[0].value_uint32 = noise_sampler_id_; args[1].value_uint32 = noise_texture_id_; - helper_->AddCommand(SET_SAMPLER_TEXTURE, 2, args); + helper_->AddCommand(SetSamplerTexture, 2, args); CHECK_ERROR(helper_); args[0].value_uint32 = noise_sampler_id_; @@ -606,7 +587,7 @@ void BubbleDemo::Initialize() { set_sampler_states::MinFilter::MakeValue(sampler::LINEAR) | set_sampler_states::MipFilter::MakeValue(sampler::NONE) | set_sampler_states::MaxAnisotropy::MakeValue(1); - helper_->AddCommand(SET_SAMPLER_STATES, 2, args); + helper_->AddCommand(SetSamplerStates, 2, args); CHECK_ERROR(helper_); // Create a 2D texture. @@ -618,7 +599,7 @@ void BubbleDemo::Initialize() { create_texture_2d_cmd::Levels::MakeValue(0) | create_texture_2d_cmd::Format::MakeValue(texture::ARGB8) | create_texture_2d_cmd::Flags::MakeValue(0); - helper_->AddCommand(CREATE_TEXTURE_2D, 3, args); + helper_->AddCommand(CreateTexture2d, 3, args); CHECK_ERROR(helper_); args[0].value_uint32 = iridescence_texture_id_; @@ -637,16 +618,16 @@ void BubbleDemo::Initialize() { args[7].value_uint32 = kTexSize; // size args[8].value_uint32 = shm_id_; args[9].value_uint32 = allocator_->GetOffset(iridescence_texture_); - helper_->AddCommand(SET_TEXTURE_DATA, 10, args); + helper_->AddCommand(SetTextureData, 10, args); CHECK_ERROR(helper_); args[0].value_uint32 = iridescence_sampler_id_; - helper_->AddCommand(CREATE_SAMPLER, 1, args); + helper_->AddCommand(CreateSampler, 1, args); CHECK_ERROR(helper_); args[0].value_uint32 = iridescence_sampler_id_; args[1].value_uint32 = iridescence_texture_id_; - helper_->AddCommand(SET_SAMPLER_TEXTURE, 2, args); + helper_->AddCommand(SetSamplerTexture, 2, args); CHECK_ERROR(helper_); args[0].value_uint32 = iridescence_sampler_id_; @@ -658,7 +639,7 @@ void BubbleDemo::Initialize() { set_sampler_states::MinFilter::MakeValue(sampler::LINEAR) | set_sampler_states::MipFilter::MakeValue(sampler::NONE) | set_sampler_states::MaxAnisotropy::MakeValue(1); - helper_->AddCommand(SET_SAMPLER_STATES, 2, args); + helper_->AddCommand(SetSamplerStates, 2, args); CHECK_ERROR(helper_); // Create a Cubemap texture. @@ -669,7 +650,7 @@ void BubbleDemo::Initialize() { create_texture_cube_cmd::Levels::MakeValue(0) | create_texture_cube_cmd::Format::MakeValue(texture::ARGB8) | create_texture_cube_cmd::Flags::MakeValue(0); - helper_->AddCommand(CREATE_TEXTURE_CUBE, 3, args); + helper_->AddCommand(CreateTextureCube, 3, args); CHECK_ERROR(helper_); for (unsigned int face = 0; face < 6; ++face) { @@ -693,18 +674,18 @@ void BubbleDemo::Initialize() { args[7].value_uint32 = kCubeMapFaceSize; // size args[8].value_uint32 = shm_id_; args[9].value_uint32 = allocator_->GetOffset(data); - helper_->AddCommand(SET_TEXTURE_DATA, 10, args); + helper_->AddCommand(SetTextureData, 10, args); CHECK_ERROR(helper_); allocator_->FreePendingToken(data, helper_->InsertToken()); } args[0].value_uint32 = cubemap_sampler_id_; - helper_->AddCommand(CREATE_SAMPLER, 1, args); + helper_->AddCommand(CreateSampler, 1, args); CHECK_ERROR(helper_); args[0].value_uint32 = cubemap_sampler_id_; args[1].value_uint32 = cubemap_id_; - helper_->AddCommand(SET_SAMPLER_TEXTURE, 2, args); + helper_->AddCommand(SetSamplerTexture, 2, args); CHECK_ERROR(helper_); args[0].value_uint32 = cubemap_sampler_id_; @@ -716,7 +697,7 @@ void BubbleDemo::Initialize() { set_sampler_states::MinFilter::MakeValue(sampler::LINEAR) | set_sampler_states::MipFilter::MakeValue(sampler::NONE) | set_sampler_states::MaxAnisotropy::MakeValue(1); - helper_->AddCommand(SET_SAMPLER_STATES, 2, args); + helper_->AddCommand(SetSamplerStates, 2, args); CHECK_ERROR(helper_); // Create the effect, and parameters. @@ -726,7 +707,7 @@ void BubbleDemo::Initialize() { args[1].value_uint32 = sizeof(effect_data); // size args[2].value_uint32 = shm_id_; // shm args[3].value_uint32 = allocator_->GetOffset(data); // offset in shm - helper_->AddCommand(CREATE_EFFECT, 4, args); + helper_->AddCommand(CreateEffect, 4, args); CHECK_ERROR(helper_); allocator_->FreePendingToken(data, helper_->InsertToken()); @@ -737,7 +718,7 @@ void BubbleDemo::Initialize() { args[2].value_uint32 = sizeof(param_name); unsigned int arg_count = CopyToArgs(args + 3, param_name, sizeof(param_name)); - helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args); + helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args); CHECK_ERROR(helper_); } @@ -748,7 +729,7 @@ void BubbleDemo::Initialize() { args[2].value_uint32 = sizeof(param_name); unsigned int arg_count = CopyToArgs(args + 3, param_name, sizeof(param_name)); - helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args); + helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args); CHECK_ERROR(helper_); } @@ -759,7 +740,7 @@ void BubbleDemo::Initialize() { args[2].value_uint32 = sizeof(param_name); unsigned int arg_count = CopyToArgs(args + 3, param_name, sizeof(param_name)); - helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args); + helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args); CHECK_ERROR(helper_); } @@ -770,7 +751,7 @@ void BubbleDemo::Initialize() { args[2].value_uint32 = sizeof(param_name); unsigned int arg_count = CopyToArgs(args + 3, param_name, sizeof(param_name)); - helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args); + helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args); CHECK_ERROR(helper_); } @@ -781,7 +762,7 @@ void BubbleDemo::Initialize() { args[2].value_uint32 = sizeof(param_name); unsigned int arg_count = CopyToArgs(args + 3, param_name, sizeof(param_name)); - helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args); + helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args); CHECK_ERROR(helper_); } @@ -792,7 +773,7 @@ void BubbleDemo::Initialize() { args[2].value_uint32 = sizeof(param_name); unsigned int arg_count = CopyToArgs(args + 3, param_name, sizeof(param_name)); - helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args); + helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args); CHECK_ERROR(helper_); } @@ -803,7 +784,7 @@ void BubbleDemo::Initialize() { args[2].value_uint32 = sizeof(param_name); unsigned int arg_count = CopyToArgs(args + 3, param_name, sizeof(param_name)); - helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args); + helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args); CHECK_ERROR(helper_); } @@ -814,7 +795,7 @@ void BubbleDemo::Initialize() { args[2].value_uint32 = sizeof(param_name); unsigned int arg_count = CopyToArgs(args + 3, param_name, sizeof(param_name)); - helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args); + helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args); CHECK_ERROR(helper_); } @@ -822,19 +803,19 @@ void BubbleDemo::Initialize() { args[0].value_uint32 = noise_sampler_param_id_; args[1].value_uint32 = sizeof(Uint32); // NOLINT args[2].value_uint32 = noise_sampler_id_; - helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 3, args); + helper_->AddCommand(SetParamDataImmediate, 3, args); CHECK_ERROR(helper_); args[0].value_uint32 = iridescence_sampler_param_id_; args[1].value_uint32 = sizeof(Uint32); // NOLINT args[2].value_uint32 = iridescence_sampler_id_; - helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 3, args); + helper_->AddCommand(SetParamDataImmediate, 3, args); CHECK_ERROR(helper_); args[0].value_uint32 = cubemap_sampler_param_id_; args[1].value_uint32 = sizeof(Uint32); // NOLINT args[2].value_uint32 = cubemap_sampler_id_; - helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 3, args); + helper_->AddCommand(SetParamDataImmediate, 3, args); CHECK_ERROR(helper_); // Create our random bubbles. @@ -900,35 +881,35 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view, // AddCommand copies the args, so it is safe to re-use args across various // calls. - // 20 is the largest command we use (SET_PARAM_DATA_IMMEDIATE for matrices). + // 20 is the largest command we use (SetParamDataImmediate for matrices). CommandBufferEntry args[20]; args[0].value_uint32 = vertex_struct_id_; - helper_->AddCommand(SET_VERTEX_STRUCT, 1, args); + helper_->AddCommand(SetVertexStruct, 1, args); CHECK_ERROR(helper_); args[0].value_uint32 = mvp_param_id_; args[1].value_uint32 = sizeof(mvp); unsigned int arg_count = CopyToArgs(args + 2, &mvp, sizeof(mvp)); - helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 2 + arg_count, args); + helper_->AddCommand(SetParamDataImmediate, 2 + arg_count, args); CHECK_ERROR(helper_); args[0].value_uint32 = world_param_id_; args[1].value_uint32 = sizeof(model); arg_count = CopyToArgs(args + 2, &model, sizeof(model)); - helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 2 + arg_count, args); + helper_->AddCommand(SetParamDataImmediate, 2 + arg_count, args); CHECK_ERROR(helper_); args[0].value_uint32 = worldIT_param_id_; args[1].value_uint32 = sizeof(modelIT); arg_count = CopyToArgs(args + 2, &modelIT, sizeof(modelIT)); - helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 2 + arg_count, args); + helper_->AddCommand(SetParamDataImmediate, 2 + arg_count, args); CHECK_ERROR(helper_); args[0].value_uint32 = eye_param_id_; args[1].value_uint32 = sizeof(eye); arg_count = CopyToArgs(args + 2, &eye, sizeof(eye)); - helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 2 + arg_count, args); + helper_->AddCommand(SetParamDataImmediate, 2 + arg_count, args); CHECK_ERROR(helper_); args[0].value_uint32 = @@ -938,11 +919,11 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view, set_blending::ColorEq::MakeValue(GAPIInterface::BLEND_EQ_ADD) | set_blending::SeparateAlpha::MakeValue(0) | set_blending::Enable::MakeValue(1); - helper_->AddCommand(SET_BLENDING, 1, args); + helper_->AddCommand(SetBlending, 1, args); CHECK_ERROR(helper_); args[0].value_uint32 = effect_id_; - helper_->AddCommand(SET_EFFECT, 1, args); + helper_->AddCommand(SetEffect, 1, args); CHECK_ERROR(helper_); // Draw back faces first. @@ -950,7 +931,7 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view, set_polygon_raster::FillMode::MakeValue( GAPIInterface::POLYGON_MODE_FILL) | set_polygon_raster::CullMode::MakeValue(GAPIInterface::CULL_CCW); - helper_->AddCommand(SET_POLYGON_RASTER, 1, args); + helper_->AddCommand(SetPolygonRaster, 1, args); CHECK_ERROR(helper_); args[0].value_uint32 = thickness_param_id_; @@ -959,7 +940,7 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view, args[3].value_float = bubble.base_thickness; args[4].value_float = bubble.noise_ratio; args[5].value_float = .5f; // back face attenuation - helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 6, args); + helper_->AddCommand(SetParamDataImmediate, 6, args); CHECK_ERROR(helper_); args[0].value_uint32 = GAPIInterface::TRIANGLES; @@ -968,7 +949,7 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view, args[3].value_uint32 = kIndexCount/3; // primitive count args[4].value_uint32 = 0; // min index args[5].value_uint32 = kVertexCount-1; // max index - helper_->AddCommand(DRAW_INDEXED, 6, args); + helper_->AddCommand(DrawIndexed, 6, args); CHECK_ERROR(helper_); // Then front faces. @@ -976,7 +957,7 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view, set_polygon_raster::FillMode::MakeValue( GAPIInterface::POLYGON_MODE_FILL) | set_polygon_raster::CullMode::MakeValue(GAPIInterface::CULL_CW); - helper_->AddCommand(SET_POLYGON_RASTER, 1, args); + helper_->AddCommand(SetPolygonRaster, 1, args); CHECK_ERROR(helper_); args[0].value_uint32 = thickness_param_id_; @@ -985,7 +966,7 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view, args[3].value_float = bubble.base_thickness; args[4].value_float = bubble.noise_ratio; args[5].value_float = 1.f; - helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 6, args); + helper_->AddCommand(SetParamDataImmediate, 6, args); CHECK_ERROR(helper_); args[0].value_uint32 = GAPIInterface::TRIANGLES; @@ -994,7 +975,7 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view, args[3].value_uint32 = kIndexCount/3; // primitive count args[4].value_uint32 = 0; // min index args[5].value_uint32 = kVertexCount-1; // max index - helper_->AddCommand(DRAW_INDEXED, 6, args); + helper_->AddCommand(DrawIndexed, 6, args); CHECK_ERROR(helper_); } @@ -1012,7 +993,7 @@ void BubbleDemo::Render() { math::CreatePerspectiveMatrix(kPi / 4.f, 1.f, .1f, 10000.f); math::Matrix4 view = math::Matrix4::lookAt(eye, target, up); - helper_->AddCommand(BEGIN_FRAME, 0 , NULL); + helper_->AddCommand(BeginFrame, 0 , NULL); CHECK_ERROR(helper_); RGBA color = {0.2f, 0.2f, 0.2f, 1.f}; ClearCmd(helper_.get(), GAPIInterface::COLOR | GAPIInterface::DEPTH, color, @@ -1026,7 +1007,7 @@ void BubbleDemo::Render() { DrawBubble(view, proj, bubble, time_ * 2.f * kPi * bubble.rotation_speed); } - helper_->AddCommand(END_FRAME, 0 , NULL); + helper_->AddCommand(EndFrame, 0 , NULL); CHECK_ERROR(helper_); helper_->Flush(); } @@ -1034,6 +1015,7 @@ void BubbleDemo::Render() { } // namespace command_buffer } // namespace o3d +#if 0 // Scriptable object for the plug-in, provides the glue with the browser. // Creates a BubbleDemo object and delegates calls to it. class Plugin : public NPObject { @@ -1264,3 +1246,60 @@ int main(int argc, char **argv) { NaClNP_MainLoop(0); return 0; } +#endif + +nacl::HtpHandle InitConnection(int argc, char **argv) { + nacl::Handle handle = nacl::kInvalidHandle; +#ifndef __native_client__ + NaClNrdAllModulesInit(); + + static nacl::SocketAddress g_address = { "command-buffer" }; + static nacl::SocketAddress g_local_address = { "cb-client" }; + + nacl::Handle sockets[2]; + nacl::SocketPair(sockets); + + nacl::MessageHeader msg; + msg.iov = NULL; + msg.iov_length = 0; + msg.handles = &sockets[1]; + msg.handle_count = 1; + nacl::Handle local_socket = nacl::BoundSocket(&g_local_address); + nacl::SendDatagramTo(local_socket, &msg, 0, &g_address); + nacl::Close(local_socket); + nacl::Close(sockets[1]); + handle = sockets[0]; +#else + if (argc < 3 || strcmp(argv[1], "-fd") != 0) { + fprintf(stderr, "Usage: %s -fd file_descriptor\n", argv[0]); + return nacl::kInvalidHtpHandle; + } + int fd = atoi(argv[2]); + handle = imc_connect(fd); + if (handle < 0) { + fprintf(stderr, "Could not connect to file descriptor %d.\n" + "Did you use the -a and -X options to sel_ldr ?\n", fd); + return nacl::kInvalidHtpHandle; + } +#endif + return nacl::CreateImcDesc(handle); +} + +void CloseConnection(nacl::HtpHandle handle) { + nacl::Close(handle); +#ifndef __native_client__ + NaClNrdAllModulesFini(); +#endif +} + +int main(int argc, char **argv) { + nacl::HtpHandle htp_handle = InitConnection(argc, argv); + if (htp_handle == nacl::kInvalidHtpHandle) { + return 1; + } + + o3d::command_buffer::BubbleDemo(htp_handle); + CloseConnection(htp_handle); + return 0; +} + diff --git a/o3d/command_buffer/service/cross/buffer_rpc_test.cc b/o3d/command_buffer/service/cross/buffer_rpc_test.cc index 42122b9..a0afd7b 100644 --- a/o3d/command_buffer/service/cross/buffer_rpc_test.cc +++ b/o3d/command_buffer/service/cross/buffer_rpc_test.cc @@ -151,8 +151,8 @@ TEST_F(BufferRPCImplTest, TestSignalGetChanges) { // is properly forwarded. TEST_F(BufferRPCImplTest, TestGetStatus) { EXPECT_CALL(buffer_sync_mock(), GetStatus()) - .WillOnce(Return(BufferSyncInterface::PARSE_ERROR)); - EXPECT_EQ(BufferSyncInterface::PARSE_ERROR, + .WillOnce(Return(BufferSyncInterface::kParseError)); + EXPECT_EQ(BufferSyncInterface::kParseError, buffer_rpc_impl()->DoCall(BufferRPCImpl::GET_STATUS, NULL, 0, NULL, 0)); } @@ -161,8 +161,8 @@ TEST_F(BufferRPCImplTest, TestGetStatus) { // is properly forwarded. TEST_F(BufferRPCImplTest, TestGetParseError) { EXPECT_CALL(buffer_sync_mock(), GetParseError()) - .WillOnce(Return(BufferSyncInterface::PARSE_OUT_OF_BOUNDS)); - EXPECT_EQ(BufferSyncInterface::PARSE_OUT_OF_BOUNDS, + .WillOnce(Return(BufferSyncInterface::kParseOutOfBounds)); + EXPECT_EQ(BufferSyncInterface::kParseOutOfBounds, buffer_rpc_impl()->DoCall(BufferRPCImpl::GET_PARSE_ERROR, NULL, 0, NULL, 0)); } diff --git a/o3d/command_buffer/service/cross/cmd_buffer_engine.cc b/o3d/command_buffer/service/cross/cmd_buffer_engine.cc index d96c63d..b39f993 100644 --- a/o3d/command_buffer/service/cross/cmd_buffer_engine.cc +++ b/o3d/command_buffer/service/cross/cmd_buffer_engine.cc @@ -47,10 +47,10 @@ CommandBufferEngine::CommandBufferEngine(AsyncAPIInterface *handler) handler_(handler), client_rpc_(NULL), token_(0), - status_(NOT_CONNECTED), + status_(kNotConnected), signal_change_(false), signal_rpc_message_id_(0), - parse_error_(PARSE_NO_ERROR) { + parse_error_(kParseNoError) { buffer_rpc_impl_.reset(new BufferRPCImpl(this)); } @@ -58,13 +58,13 @@ CommandBufferEngine::~CommandBufferEngine() {} // Inits the connection. Registers the client RPC service. void CommandBufferEngine::InitConnection() { - status_ = NO_BUFFER; + status_ = kNoBuffer; } // Closes the connection. Executes all remaining commands. void CommandBufferEngine::CloseConnection() { FinishParsing(); - status_ = NOT_CONNECTED; + status_ = kNotConnected; parser_.reset(NULL); } @@ -113,13 +113,13 @@ void CommandBufferEngine::SetCommandBuffer(unsigned int shm_id, << "shared memory"; return; } - if (status_ == NOT_CONNECTED) return; + if (status_ == kNotConnected) return; FinishParsing(); parser_.reset(new CommandParser(shared_memory_buffers_[shm_id].address, shared_memory_buffers_[shm_id].size, offset, size, start_get, handler_)); - status_ = PARSING; - parse_error_ = PARSE_NO_ERROR; + status_ = kParsing; + parse_error_ = kParseNoError; } // Changes the put value. @@ -145,12 +145,12 @@ unsigned int CommandBufferEngine::GetToken() { // Executes commands until get is different from the value passed in. It will // return immediately if the get value is already different, or if the engine -// is not in the PARSING status, or if the buffer is empty. It will return -1 +// is not in the kParsing status, or if the buffer is empty. It will return -1 // if there is no current buffer. CommandBufferOffset CommandBufferEngine::WaitGetChanges( CommandBufferOffset current_value) { if (parser_.get()) { - while (status_ == PARSING && + while (status_ == kParsing && parser_->get() == current_value && !parser_->IsEmpty()) { ProcessOneCommand(); @@ -162,12 +162,12 @@ CommandBufferOffset CommandBufferEngine::WaitGetChanges( } // Signals the client when get gets different from the value passed in. If get -// is already different, or if the engine is not in the PARSING status, that +// is already different, or if the engine is not in the kParsing status, that // will happen immediately, otherwise it will happen when commands get // executed, moving the get pointer. void CommandBufferEngine::SignalGetChanges(CommandBufferOffset current_value, int rpc_message_id) { - if (status_ != PARSING || parser_->get() != current_value) { + if (status_ != kParsing || parser_->get() != current_value) { DoSignalChangedGet(rpc_message_id); } else { signal_change_ = true; @@ -200,10 +200,10 @@ BufferSyncInterface::ParserStatus CommandBufferEngine::GetStatus() { return status_; } -// Gets the current parse error, reset it to PARSE_NO_ERROR. +// Gets the current parse error, reset it to kParseNoError. BufferSyncInterface::ParseError CommandBufferEngine::GetParseError() { ParseError error = parse_error_; - parse_error_ = PARSE_NO_ERROR; + parse_error_ = kParseNoError; return error; } @@ -211,32 +211,32 @@ BufferSyncInterface::ParseError CommandBufferEngine::GetParseError() { // parsing error occurs. void CommandBufferEngine::FinishParsing() { // terminates current parsing, that is, execute all the commands - // NOTE: status_ == PARSING implies parser_ != NULL - while (status_ == PARSING && !parser_->IsEmpty()) { + // NOTE: status_ == kParsing implies parser_ != NULL + while (status_ == kParsing && !parser_->IsEmpty()) { ProcessOneCommand(); } } // Processes one command from the command buffer. This must only be called when -// in the PARSING status. +// in the kParsing status. // This will update the status_ and the parse_error_ fields if an error occurs. void CommandBufferEngine::ProcessOneCommand() { - DCHECK_EQ(PARSING, status_); + DCHECK_EQ(kParsing, status_); DCHECK(parser_.get()); ParseError result = parser_->ProcessCommand(); switch (result) { - case PARSE_NO_ERROR: + case kParseNoError: break; - case PARSE_OUT_OF_BOUNDS: - case PARSE_INVALID_SIZE: - status_ = PARSE_ERROR; + case kParseOutOfBounds: + case kParseInvalidSize: + status_ = kParseError; // Always override the error, to properly signal the stopping condition. parse_error_ = result; break; - case PARSE_INVALID_ARGUMENTS: - case PARSE_UNKNOWN_COMMAND: + case kParseInvalidArguments: + case kParseUnknownCommand: // Only set the error if it is not set already. - if (parse_error_ == PARSE_NO_ERROR) { + if (parse_error_ == kParseNoError) { parse_error_ = result; } break; @@ -255,16 +255,16 @@ void CommandBufferEngine::DoMainLoop() { while (DoWork()) { } // Clean up if needed: execute all pending commands, then close the // connection. - if (status_ != NOT_CONNECTED) CloseConnection(); + if (status_ != kNotConnected) CloseConnection(); } bool CommandBufferEngine::HasWork() { - return (status_ == PARSING && !parser_->IsEmpty()) || + return (status_ == kParsing && !parser_->IsEmpty()) || process_interface_->HasMessage(); } bool CommandBufferEngine::DoWork() { - if (status_ == PARSING && !parser_->IsEmpty()) { + if (status_ == kParsing && !parser_->IsEmpty()) { bool running = true; // process as many messages as available but do not block. while (process_interface_->HasMessage()) { diff --git a/o3d/command_buffer/service/cross/cmd_buffer_engine.h b/o3d/command_buffer/service/cross/cmd_buffer_engine.h index 824f4f6..572d98f 100644 --- a/o3d/command_buffer/service/cross/cmd_buffer_engine.h +++ b/o3d/command_buffer/service/cross/cmd_buffer_engine.h @@ -131,8 +131,8 @@ class CommandBufferEngine : public BufferSyncInterface { // Gets the current parse error. The current parse error is set when the // service is in the PARSE_ERROR status. It may also be set while in the - // PARSING state, if a recoverable error (like PARSE_UNKNOWN_METHOD) was - // encountered. Getting the error resets it to PARSE_NO_ERROR. + // kParsing state, if a recoverable error (like PARSE_UNKNOWN_METHOD) was + // encountered. Getting the error resets it to kParseNoError. // Returns: // The current parse error. virtual ParseError GetParseError(); diff --git a/o3d/command_buffer/service/cross/cmd_buffer_engine_test.cc b/o3d/command_buffer/service/cross/cmd_buffer_engine_test.cc index 14f56ec..c217e4c 100644 --- a/o3d/command_buffer/service/cross/cmd_buffer_engine_test.cc +++ b/o3d/command_buffer/service/cross/cmd_buffer_engine_test.cc @@ -133,21 +133,21 @@ TEST_F(CommandBufferEngineTest, TestInitialization) { // Check initial state EXPECT_TRUE(engine()->rpc_impl() != NULL); EXPECT_TRUE(engine()->parser() == NULL); - EXPECT_EQ(BufferSyncInterface::NOT_CONNECTED, engine()->GetStatus()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + EXPECT_EQ(BufferSyncInterface::kNotConnected, engine()->GetStatus()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); EXPECT_EQ(-1, engine()->Get()); EXPECT_EQ(0, engine()->GetToken()); engine()->InitConnection(); - EXPECT_EQ(BufferSyncInterface::NO_BUFFER, engine()->GetStatus()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + EXPECT_EQ(BufferSyncInterface::kNoBuffer, engine()->GetStatus()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); EXPECT_EQ(-1, engine()->Get()); CommandBufferEntry *entries = InitCommandBuffer(25, 5); ASSERT_TRUE(entries != NULL); - EXPECT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + EXPECT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); EXPECT_EQ(5, engine()->Get()); EXPECT_TRUE(engine()->parser() != NULL); @@ -157,8 +157,8 @@ TEST_F(CommandBufferEngineTest, TestInitialization) { engine()->CloseConnection(); DestroyCommandBuffer(); - EXPECT_EQ(BufferSyncInterface::NOT_CONNECTED, engine()->GetStatus()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + EXPECT_EQ(BufferSyncInterface::kNotConnected, engine()->GetStatus()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); EXPECT_EQ(-1, engine()->Get()); EXPECT_TRUE(engine()->parser() == NULL); } @@ -231,7 +231,7 @@ TEST_F(CommandBufferEngineTest, TestCommandProcessing) { // Create a command buffer with 3 commands put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 0, 0, NULL); @@ -240,7 +240,7 @@ TEST_F(CommandBufferEngineTest, TestCommandProcessing) { args1[0].value_uint32 = 3; args1[1].value_float = 4.f; put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 1, 2, args1); @@ -249,7 +249,7 @@ TEST_F(CommandBufferEngineTest, TestCommandProcessing) { args2[0].value_uint32 = 5; args2[1].value_float = 6.f; put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 2, 2, args2); @@ -259,8 +259,8 @@ TEST_F(CommandBufferEngineTest, TestCommandProcessing) { // Check that the parsing progresses, and that no error occurs. CommandBufferOffset new_get = engine()->WaitGetChanges(get); EXPECT_NE(get, new_get); - ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); EXPECT_EQ(new_get, engine()->Get()); get = new_get; } @@ -283,7 +283,7 @@ TEST_F(CommandBufferEngineTest, TestCommandWrapping) { // Create a command buffer with 3 commands put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 0, 0, NULL); @@ -292,7 +292,7 @@ TEST_F(CommandBufferEngineTest, TestCommandWrapping) { args1[0].value_uint32 = 3; args1[1].value_float = 4.f; put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 1, 2, args1); @@ -303,7 +303,7 @@ TEST_F(CommandBufferEngineTest, TestCommandWrapping) { args2[0].value_uint32 = 5; args2[1].value_float = 6.f; put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 2, 2, args2); @@ -313,8 +313,8 @@ TEST_F(CommandBufferEngineTest, TestCommandWrapping) { // Check that the parsing progresses, and that no error occurs. CommandBufferOffset new_get = engine()->WaitGetChanges(get); EXPECT_NE(get, new_get); - ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); EXPECT_EQ(new_get, engine()->Get()); get = new_get; } @@ -337,7 +337,7 @@ TEST_F(CommandBufferEngineTest, TestSetBufferAndClose) { // Create a command buffer with 3 commands put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 0, 0, NULL); @@ -346,7 +346,7 @@ TEST_F(CommandBufferEngineTest, TestSetBufferAndClose) { args1[0].value_uint32 = 3; args1[1].value_float = 4.f; put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 1, 2, args1); @@ -355,7 +355,7 @@ TEST_F(CommandBufferEngineTest, TestSetBufferAndClose) { args2[0].value_uint32 = 5; args2[1].value_float = 6.f; put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 2, 2, args2); @@ -371,8 +371,8 @@ TEST_F(CommandBufferEngineTest, TestSetBufferAndClose) { CommandBufferEntry *entries2 = static_cast<CommandBufferEntry *>( engine()->GetSharedMemoryAddress(shm_id)); engine()->SetCommandBuffer(shm_id, 0, kShmSize, 0); - EXPECT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + EXPECT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); EXPECT_EQ(0, engine()->Get()); // Destroy the old command buffer. @@ -381,7 +381,7 @@ TEST_F(CommandBufferEngineTest, TestSetBufferAndClose) { get = engine()->Get(); put = get; put += AddCommandWithExpect(entries2 + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 1, 2, args1); @@ -409,7 +409,7 @@ TEST_F(CommandBufferEngineTest, TestRecoverableError) { // Create a command buffer with 3 commands, 2 of them generating errors put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 0, 0, NULL); @@ -418,7 +418,7 @@ TEST_F(CommandBufferEngineTest, TestRecoverableError) { args1[0].value_uint32 = 3; args1[1].value_float = 4.f; put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_INVALID_ARGUMENTS, + BufferSyncInterface::kParseInvalidArguments, 1, 2, args1); @@ -427,7 +427,7 @@ TEST_F(CommandBufferEngineTest, TestRecoverableError) { args2[0].value_uint32 = 5; args2[1].value_float = 6.f; put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_UNKNOWN_COMMAND, + BufferSyncInterface::kParseUnknownCommand, 2, 2, args2); @@ -437,7 +437,7 @@ TEST_F(CommandBufferEngineTest, TestRecoverableError) { // Check that the parsing progresses, and that no error occurs. CommandBufferOffset new_get = engine()->WaitGetChanges(get); EXPECT_NE(get, new_get); - ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus()); + ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus()); EXPECT_EQ(new_get, engine()->Get()); get = new_get; } @@ -445,10 +445,10 @@ TEST_F(CommandBufferEngineTest, TestRecoverableError) { Mock::VerifyAndClearExpectations(api_mock()); // Check that the error status was set to the first error. - EXPECT_EQ(BufferSyncInterface::PARSE_INVALID_ARGUMENTS, + EXPECT_EQ(BufferSyncInterface::kParseInvalidArguments, engine()->GetParseError()); // Check that the error status was reset after the query. - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); engine()->CloseConnection(); DestroyCommandBuffer(); @@ -477,7 +477,7 @@ TEST_F(CommandBufferEngineTest, TestNonRecoverableError) { // Create a command buffer with 3 commands, the last one overlapping the end // of the buffer. put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 0, 0, NULL); @@ -486,7 +486,7 @@ TEST_F(CommandBufferEngineTest, TestNonRecoverableError) { args1[0].value_uint32 = 3; args1[1].value_float = 4.f; put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 1, 2, args1); @@ -514,12 +514,12 @@ TEST_F(CommandBufferEngineTest, TestNonRecoverableError) { get = new_get; } // We should be in an error case now. - EXPECT_EQ(BufferSyncInterface::PARSE_ERROR, engine()->GetStatus()); + EXPECT_EQ(BufferSyncInterface::kParseError, engine()->GetStatus()); // Check that the error status was set to the first error. - EXPECT_EQ(BufferSyncInterface::PARSE_OUT_OF_BOUNDS, + EXPECT_EQ(BufferSyncInterface::kParseOutOfBounds, engine()->GetParseError()); // Check that the error status was reset after the query. - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); // Check that the valid commands did happen. Mock::VerifyAndClearExpectations(api_mock()); @@ -568,7 +568,7 @@ TEST_F(CommandBufferEngineTest, TestDoWork) { process_mock()->Reset(); EXPECT_CALL(*process_mock(), HasMessage()).Times(AnyNumber()); put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 0, 0, NULL); @@ -577,7 +577,7 @@ TEST_F(CommandBufferEngineTest, TestDoWork) { args1[0].value_uint32 = 3; args1[1].value_float = 4.f; put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 1, 2, args1); @@ -586,7 +586,7 @@ TEST_F(CommandBufferEngineTest, TestDoWork) { args2[0].value_uint32 = 5; args2[1].value_float = 6.f; put += AddCommandWithExpect(entries + put, - BufferSyncInterface::PARSE_NO_ERROR, + BufferSyncInterface::kParseNoError, 2, 2, args2); @@ -603,8 +603,8 @@ TEST_F(CommandBufferEngineTest, TestDoWork) { EXPECT_FALSE(process_mock()->would_have_blocked()); get = engine()->Get(); EXPECT_EQ(put, get); // once we're done, we should have executed everything. - ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError()); + ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError()); Mock::VerifyAndClearExpectations(process_mock()); Mock::VerifyAndClearExpectations(api_mock()); diff --git a/o3d/command_buffer/service/cross/cmd_parser.cc b/o3d/command_buffer/service/cross/cmd_parser.cc index a640d3d..843d0b8 100644 --- a/o3d/command_buffer/service/cross/cmd_parser.cc +++ b/o3d/command_buffer/service/cross/cmd_parser.cc @@ -66,14 +66,14 @@ CommandParser::CommandParser(void *shm_address, // - get_ is modified *after* the command has been executed. BufferSyncInterface::ParseError CommandParser::ProcessCommand() { CommandBufferOffset get = get_; - if (get == put_) return BufferSyncInterface::PARSE_NO_ERROR; + if (get == put_) return BufferSyncInterface::kParseNoError; CommandHeader header = buffer_[get].value_header; - if (header.size == 0) return BufferSyncInterface::PARSE_INVALID_SIZE; + if (header.size == 0) return BufferSyncInterface::kParseInvalidSize; if (header.size + get > entry_count_) - return BufferSyncInterface::PARSE_OUT_OF_BOUNDS; + return BufferSyncInterface::kParseOutOfBounds; BufferSyncInterface::ParseError result = handler_->DoCommand( - header.command, header.size - 1, buffer_ + get + 1); + header.command, header.size - 1, buffer_ + get); get_ = (get + header.size) % entry_count_; return result; } @@ -85,7 +85,7 @@ BufferSyncInterface::ParseError CommandParser::ProcessAllCommands() { BufferSyncInterface::ParseError error = ProcessCommand(); if (error) return error; } - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } } // namespace command_buffer diff --git a/o3d/command_buffer/service/cross/cmd_parser.h b/o3d/command_buffer/service/cross/cmd_parser.h index 9c3a145..425e8d9 100644 --- a/o3d/command_buffer/service/cross/cmd_parser.h +++ b/o3d/command_buffer/service/cross/cmd_parser.h @@ -97,14 +97,14 @@ class AsyncAPIInterface { // Parameters: // command: the command index. // arg_count: the number of CommandBufferEntry arguments. - // args: the arguments. + // cmd_data: the command data. // Returns: // BufferSyncInterface::NO_ERROR if no error was found, one of // BufferSyncInterface::ParseError otherwise. virtual BufferSyncInterface::ParseError DoCommand( unsigned int command, unsigned int arg_count, - const void* args) = 0; + const void* cmd_data) = 0; }; } // namespace command_buffer diff --git a/o3d/command_buffer/service/cross/cmd_parser_test.cc b/o3d/command_buffer/service/cross/cmd_parser_test.cc index a63489c..3d50d8a 100644 --- a/o3d/command_buffer/service/cross/cmd_parser_test.cc +++ b/o3d/command_buffer/service/cross/cmd_parser_test.cc @@ -115,8 +115,8 @@ TEST_F(CommandParserTest, TestSimple) { parser->set_put(put); EXPECT_EQ(put, parser->put()); - AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 123, 0, NULL); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessCommand()); + AddDoCommandExpect(BufferSyncInterface::kParseNoError, 123, 0, NULL); + EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessCommand()); EXPECT_EQ(put, parser->get()); Mock::VerifyAndClearExpectations(api_mock()); @@ -133,8 +133,8 @@ TEST_F(CommandParserTest, TestSimple) { CommandBufferEntry param_array[2]; param_array[0].value_int32 = 2134; param_array[1].value_float = 1.f; - AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 456, 2, param_array); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessCommand()); + AddDoCommandExpect(BufferSyncInterface::kParseNoError, 456, 2, param_array); + EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessCommand()); EXPECT_EQ(put, parser->get()); Mock::VerifyAndClearExpectations(api_mock()); } @@ -162,14 +162,14 @@ TEST_F(CommandParserTest, TestMultipleCommands) { CommandBufferEntry param_array[2]; param_array[0].value_int32 = 5151; - AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 789, 1, param_array); + AddDoCommandExpect(BufferSyncInterface::kParseNoError, 789, 1, param_array); param_array[1].value_int32 = 3434; - AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 2121, 1, + AddDoCommandExpect(BufferSyncInterface::kParseNoError, 2121, 1, param_array+1); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessCommand()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessCommand()); EXPECT_EQ(put_cmd2, parser->get()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessCommand()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessCommand()); EXPECT_EQ(put, parser->get()); Mock::VerifyAndClearExpectations(api_mock()); @@ -188,12 +188,12 @@ TEST_F(CommandParserTest, TestMultipleCommands) { EXPECT_EQ(put, parser->put()); param_array[0].value_int32 = 5656; - AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 4545, 1, param_array); + AddDoCommandExpect(BufferSyncInterface::kParseNoError, 4545, 1, param_array); param_array[1].value_int32 = 7878; - AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 6767, 1, + AddDoCommandExpect(BufferSyncInterface::kParseNoError, 6767, 1, param_array+1); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessAllCommands()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessAllCommands()); EXPECT_EQ(put, parser->get()); Mock::VerifyAndClearExpectations(api_mock()); } @@ -209,11 +209,11 @@ TEST_F(CommandParserTest, TestWrap) { header.size = 1; header.command = i; buffer()[put++].value_header = header; - AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, i, 0, NULL); + AddDoCommandExpect(BufferSyncInterface::kParseNoError, i, 0, NULL); } parser->set_put(put); EXPECT_EQ(put, parser->put()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessAllCommands()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessAllCommands()); EXPECT_EQ(put, parser->get()); Mock::VerifyAndClearExpectations(api_mock()); @@ -225,13 +225,13 @@ TEST_F(CommandParserTest, TestWrap) { buffer()[put++].value_int32 = 5; CommandBufferEntry param; param.value_int32 = 5; - AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 3, 1, ¶m); + AddDoCommandExpect(BufferSyncInterface::kParseNoError, 3, 1, ¶m); DCHECK_EQ(5, put); put = 0; parser->set_put(put); EXPECT_EQ(put, parser->put()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessAllCommands()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessAllCommands()); EXPECT_EQ(put, parser->get()); Mock::VerifyAndClearExpectations(api_mock()); @@ -241,10 +241,10 @@ TEST_F(CommandParserTest, TestWrap) { buffer()[put++].value_header = header; buffer()[put++].value_int32 = 6; param.value_int32 = 6; - AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 4, 1, ¶m); + AddDoCommandExpect(BufferSyncInterface::kParseNoError, 4, 1, ¶m); parser->set_put(put); EXPECT_EQ(put, parser->put()); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessAllCommands()); + EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessAllCommands()); EXPECT_EQ(put, parser->get()); Mock::VerifyAndClearExpectations(api_mock()); } @@ -262,7 +262,7 @@ TEST_F(CommandParserTest, TestError) { parser->set_put(put); EXPECT_EQ(put, parser->put()); - EXPECT_EQ(BufferSyncInterface::PARSE_INVALID_SIZE, + EXPECT_EQ(BufferSyncInterface::kParseInvalidSize, parser->ProcessAllCommands()); // check that no DoCommand call was made. Mock::VerifyAndClearExpectations(api_mock()); @@ -277,7 +277,7 @@ TEST_F(CommandParserTest, TestError) { parser->set_put(put); EXPECT_EQ(put, parser->put()); - EXPECT_EQ(BufferSyncInterface::PARSE_OUT_OF_BOUNDS, + EXPECT_EQ(BufferSyncInterface::kParseOutOfBounds, parser->ProcessAllCommands()); // check that no DoCommand call was made. Mock::VerifyAndClearExpectations(api_mock()); @@ -297,16 +297,16 @@ TEST_F(CommandParserTest, TestError) { parser->set_put(put); EXPECT_EQ(put, parser->put()); // have the first command fail to parse. - AddDoCommandExpect(BufferSyncInterface::PARSE_UNKNOWN_COMMAND, 3, 0, NULL); - EXPECT_EQ(BufferSyncInterface::PARSE_UNKNOWN_COMMAND, + AddDoCommandExpect(BufferSyncInterface::kParseUnknownCommand, 3, 0, NULL); + EXPECT_EQ(BufferSyncInterface::kParseUnknownCommand, parser->ProcessAllCommands()); // check that only one command was executed, and that get reflects that // correctly. EXPECT_EQ(put_post_fail, parser->get()); Mock::VerifyAndClearExpectations(api_mock()); // make the second one succeed, and check that the parser recovered fine. - AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 4, 0, NULL); - EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessAllCommands()); + AddDoCommandExpect(BufferSyncInterface::kParseNoError, 4, 0, NULL); + EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessAllCommands()); EXPECT_EQ(put, parser->get()); Mock::VerifyAndClearExpectations(api_mock()); } diff --git a/o3d/command_buffer/service/cross/effect_utils.h b/o3d/command_buffer/service/cross/effect_utils.h index 2402254..e4bad72 100644 --- a/o3d/command_buffer/service/cross/effect_utils.h +++ b/o3d/command_buffer/service/cross/effect_utils.h @@ -40,7 +40,7 @@ namespace o3d { namespace command_buffer { -// This function parses the data passed to the CREATE_EFFECT commands, which +// This function parses the data passed to the CreateEffect commands, which // follows the following format: // vertex_program_entry \0 fragment_program_entry \0 effect_code // It returns the various components. diff --git a/o3d/command_buffer/service/cross/gapi_decoder.cc b/o3d/command_buffer/service/cross/gapi_decoder.cc index aa9f019..e19b67a 100644 --- a/o3d/command_buffer/service/cross/gapi_decoder.cc +++ b/o3d/command_buffer/service/cross/gapi_decoder.cc @@ -43,30 +43,32 @@ namespace command_buffer { namespace { +// Returns the address of the first byte after a struct. template <typename T> const void* AddressAfterStruct(const T& pod) { return reinterpret_cast<const uint8*>(&pod) + sizeof(pod); } +// Returns the size in bytes of the data of an Immediate command, a command with +// its data inline in the command buffer. template <typename T> -unsigned int ImmediateSize(uint32 arg_count, const T& pod) { - return (arg_count - sizeof(pod) / sizeof(uint32)) * sizeof(uint32); -} - -// TODO(gman): Remove this. -CommandBufferEntry* TempHack(const void* foo) { - return reinterpret_cast<CommandBufferEntry*>(const_cast<void*>(foo)); +unsigned int ImmediateDataSize(uint32 arg_count, const T& pod) { + return static_cast<unsigned int>( + (arg_count + 1 - ComputeNumEntries(sizeof(pod))) * + sizeof(CommandBufferEntry)); // NOLINT } +// A struct to hold info about each command. struct CommandInfo { - int arg_flags; - int arg_count; + int arg_flags; // How to handle the arguments for this command + int arg_count; // How many arguments are expected for this command. }; +// A table of CommandInfo for all the commands. const CommandInfo g_command_info[] = { - #define O3D_COMMAND_BUFFER_CMD_OP(name) { \ - cmd::name::kArgFlags, \ - sizeof(cmd::name) / sizeof(uint32), }, \ + #define O3D_COMMAND_BUFFER_CMD_OP(name) { \ + cmd::name::kArgFlags, \ + sizeof(cmd::name) / sizeof(CommandBufferEntry) - 1, }, /* NOLINT */ \ O3D_COMMAND_BUFFER_CMDS @@ -83,355 +85,28 @@ const CommandInfo g_command_info[] = { BufferSyncInterface::ParseError GAPIDecoder::DoCommand( unsigned int command, unsigned int arg_count, - const void* args) { + const void* cmd_data) { if (command < arraysize(g_command_info)) { const CommandInfo& info = g_command_info[command]; - unsigned int info_arg_count = static_cast<unsigned int>(info.arg_count); + unsigned int info_arg_count = static_cast<unsigned int>(info.arg_count); if ((info.arg_flags == cmd::kFixed && arg_count == info_arg_count) || (info.arg_flags == cmd::kAtLeastN && arg_count > info_arg_count)) { switch (command) { #define O3D_COMMAND_BUFFER_CMD_OP(name) \ case cmd::name::kCmdId: \ - return Handle_ ## name( \ + return Handle ## name( \ arg_count, \ - *static_cast<const cmd::name*>(args)); \ + *static_cast<const cmd::name*>(cmd_data)); \ O3D_COMMAND_BUFFER_CMDS #undef O3D_COMMAND_BUFFER_CMD_OP } } else { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } } - return BufferSyncInterface::PARSE_UNKNOWN_COMMAND; -} - - -// Decodes the SET_VERTEX_INPUT command. -BufferSyncInterface::ParseError GAPIDecoder::DecodeSetVertexInput( - unsigned int arg_count, - CommandBufferEntry *args) { - namespace cmd = set_vertex_input_cmd; - if (arg_count != 5) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - ResourceID vertex_struct_id = args[0].value_uint32; - unsigned int input_index = args[1].value_uint32; - ResourceID vertex_buffer_id = args[2].value_uint32; - unsigned int offset = args[3].value_uint32; - unsigned int type_stride_semantic = args[4].value_uint32; - unsigned int semantic_index = cmd::SemanticIndex::Get(type_stride_semantic); - unsigned int semantic = cmd::Semantic::Get(type_stride_semantic); - unsigned int type = cmd::Type::Get(type_stride_semantic); - unsigned int stride = cmd::Stride::Get(type_stride_semantic); - if (semantic >= vertex_struct::NUM_SEMANTICS || - type >= vertex_struct::NUM_TYPES || stride == 0) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - return gapi_->SetVertexInput(vertex_struct_id, input_index, vertex_buffer_id, - offset, stride, - static_cast<vertex_struct::Type>(type), - static_cast<vertex_struct::Semantic>(semantic), - semantic_index); -} - -// Decodes the CREATE_TEXTURE_2D command. -BufferSyncInterface::ParseError GAPIDecoder::DecodeCreateTexture2D( - unsigned int arg_count, - CommandBufferEntry *args) { - if (arg_count == 3) { - namespace cmd = create_texture_2d_cmd; - unsigned int id = args[0].value_uint32; - unsigned int width_height = args[1].value_uint32; - unsigned int levels_format_flags = args[2].value_uint32; - unsigned int width = cmd::Width::Get(width_height); - unsigned int height = cmd::Height::Get(width_height); - unsigned int levels = cmd::Levels::Get(levels_format_flags); - unsigned int unused = cmd::Unused::Get(levels_format_flags); - unsigned int format = cmd::Format::Get(levels_format_flags); - unsigned int flags = cmd::Flags::Get(levels_format_flags); - unsigned int max_levels = - 1 + base::bits::Log2Ceiling(std::max(width, height)); - if ((width == 0) || (height == 0) || (levels > max_levels) || - (unused != 0) || (format >= texture::NUM_FORMATS)) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - if (levels == 0) levels = max_levels; - bool enable_render_surfaces = !!flags; - return gapi_->CreateTexture2D(id, width, height, levels, - static_cast<texture::Format>(format), flags, - enable_render_surfaces); - } else { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - } -} - -// Decodes the CREATE_TEXTURE_3D command. -BufferSyncInterface::ParseError GAPIDecoder::DecodeCreateTexture3D( - unsigned int arg_count, - CommandBufferEntry *args) { - if (arg_count == 4) { - namespace cmd = create_texture_3d_cmd; - unsigned int id = args[0].value_uint32; - unsigned int width_height = args[1].value_uint32; - unsigned int depth_unused = args[2].value_uint32; - unsigned int levels_format_flags = args[3].value_uint32; - unsigned int width = cmd::Width::Get(width_height); - unsigned int height = cmd::Height::Get(width_height); - unsigned int depth = cmd::Depth::Get(depth_unused); - unsigned int unused1 = cmd::Unused1::Get(depth_unused); - unsigned int levels = cmd::Levels::Get(levels_format_flags); - unsigned int unused2 = cmd::Unused2::Get(levels_format_flags); - unsigned int format = cmd::Format::Get(levels_format_flags); - unsigned int flags = cmd::Flags::Get(levels_format_flags); - unsigned int max_levels = - 1 + base::bits::Log2Ceiling(std::max(depth, std::max(width, height))); - if ((width == 0) || (height == 0) || (depth == 0) || - (levels > max_levels) || (unused1 != 0) || (unused2 != 0) || - (format >= texture::NUM_FORMATS)) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - if (levels == 0) levels = max_levels; - bool enable_render_surfaces = !!flags; - return gapi_->CreateTexture3D(id, width, height, depth, levels, - static_cast<texture::Format>(format), flags, - enable_render_surfaces); - } else { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - } -} - -// Decodes the CREATE_TEXTURE_CUBE command. -BufferSyncInterface::ParseError GAPIDecoder::DecodeCreateTextureCube( - unsigned int arg_count, - CommandBufferEntry *args) { - if (arg_count == 3) { - namespace cmd = create_texture_cube_cmd; - unsigned int id = args[0].value_uint32; - unsigned int side_unused = args[1].value_uint32; - unsigned int levels_format_flags = args[2].value_uint32; - unsigned int side = cmd::Side::Get(side_unused); - unsigned int unused1 = cmd::Unused1::Get(side_unused); - unsigned int levels = cmd::Levels::Get(levels_format_flags); - unsigned int unused2 = cmd::Unused2::Get(levels_format_flags); - unsigned int format = cmd::Format::Get(levels_format_flags); - unsigned int flags = cmd::Flags::Get(levels_format_flags); - unsigned int max_levels = 1 + base::bits::Log2Ceiling(side); - if ((side == 0) || (levels > max_levels) || (unused1 != 0) || - (unused2 != 0) || (format >= texture::NUM_FORMATS)) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - if (levels == 0) levels = max_levels; - bool enable_render_surfaces = !!flags; - return gapi_->CreateTextureCube(id, side, levels, - static_cast<texture::Format>(format), - flags, enable_render_surfaces); - } else { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - } -} - -// Decodes the SET_TEXTURE_DATA command. -BufferSyncInterface::ParseError GAPIDecoder::DecodeSetTextureData( - unsigned int arg_count, - CommandBufferEntry *args) { - if (arg_count == 10) { - namespace cmd = set_texture_data_cmd; - unsigned int id = args[0].value_uint32; - unsigned int x_y = args[1].value_uint32; - unsigned int width_height = args[2].value_uint32; - unsigned int z_depth = args[3].value_uint32; - unsigned int level_face = args[4].value_uint32; - unsigned int row_pitch = args[5].value_uint32; - unsigned int slice_pitch = args[6].value_uint32; - unsigned int size = args[7].value_uint32; - unsigned int shm_id = args[8].value_uint32; - unsigned int offset = args[9].value_uint32; - unsigned int x = cmd::X::Get(x_y); - unsigned int y = cmd::Y::Get(x_y); - unsigned int width = cmd::Width::Get(width_height); - unsigned int height = cmd::Height::Get(width_height); - unsigned int z = cmd::Z::Get(z_depth); - unsigned int depth = cmd::Depth::Get(z_depth); - unsigned int level = cmd::Level::Get(level_face); - unsigned int face = cmd::Face::Get(level_face); - unsigned int unused = cmd::Unused::Get(level_face); - const void *data = GetAddressAndCheckSize(shm_id, offset, size); - if (face >= 6 || unused != 0 || !data) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - return gapi_->SetTextureData(id, x, y, z, width, height, depth, level, - static_cast<texture::Face>(face), row_pitch, - slice_pitch, size, data); - - } else { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - } -} - -// Decodes the SET_TEXTURE_DATA_IMMEDIATE command. -BufferSyncInterface::ParseError GAPIDecoder::DecodeSetTextureDataImmediate( - unsigned int arg_count, - CommandBufferEntry *args) { - if (arg_count > 8) { - namespace cmd = set_texture_data_immediate_cmd; - unsigned int id = args[0].value_uint32; - unsigned int x_y = args[1].value_uint32; - unsigned int width_height = args[2].value_uint32; - unsigned int z_depth = args[3].value_uint32; - unsigned int level_face = args[4].value_uint32; - unsigned int row_pitch = args[5].value_uint32; - unsigned int slice_pitch = args[6].value_uint32; - unsigned int size = args[7].value_uint32; - unsigned int x = cmd::X::Get(x_y); - unsigned int y = cmd::Y::Get(x_y); - unsigned int width = cmd::Width::Get(width_height); - unsigned int height = cmd::Height::Get(width_height); - unsigned int z = cmd::Z::Get(z_depth); - unsigned int depth = cmd::Depth::Get(z_depth); - unsigned int level = cmd::Level::Get(level_face); - unsigned int face = cmd::Face::Get(level_face); - unsigned int unused = cmd::Unused::Get(level_face); - if (face >= 6 || unused != 0 || - size > (arg_count - 5) * sizeof(args[0])) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - return gapi_->SetTextureData(id, x, y, z, width, height, depth, level, - static_cast<texture::Face>(face), row_pitch, - slice_pitch, size, args + 8); - } else { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - } -} - -// Decodes the GET_TEXTURE_DATA command. -BufferSyncInterface::ParseError GAPIDecoder::DecodeGetTextureData( - unsigned int arg_count, - CommandBufferEntry *args) { - if (arg_count == 10) { - namespace cmd = get_texture_data_cmd; - unsigned int id = args[0].value_uint32; - unsigned int x_y = args[1].value_uint32; - unsigned int width_height = args[2].value_uint32; - unsigned int z_depth = args[3].value_uint32; - unsigned int level_face = args[4].value_uint32; - unsigned int row_pitch = args[5].value_uint32; - unsigned int slice_pitch = args[6].value_uint32; - unsigned int size = args[7].value_uint32; - unsigned int shm_id = args[8].value_uint32; - unsigned int offset = args[9].value_uint32; - unsigned int x = cmd::X::Get(x_y); - unsigned int y = cmd::Y::Get(x_y); - unsigned int width = cmd::Width::Get(width_height); - unsigned int height = cmd::Height::Get(width_height); - unsigned int z = cmd::Z::Get(z_depth); - unsigned int depth = cmd::Depth::Get(z_depth); - unsigned int level = cmd::Level::Get(level_face); - unsigned int face = cmd::Face::Get(level_face); - unsigned int unused = cmd::Unused::Get(level_face); - void *data = GetAddressAndCheckSize(shm_id, offset, size); - if (face >= 6 || unused != 0 || !data) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - return gapi_->GetTextureData(id, x, y, z, width, height, depth, level, - static_cast<texture::Face>(face), row_pitch, - slice_pitch, size, data); - - } else { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - } -} - -// Decodes the SET_SAMPLER_STATES command. -BufferSyncInterface::ParseError GAPIDecoder::DecodeSetSamplerStates( - unsigned int arg_count, - CommandBufferEntry *args) { - namespace cmd = set_sampler_states; - if (arg_count != 2) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - ResourceID id = args[0].value_uint32; - Uint32 arg = args[1].value_uint32; - if (cmd::Unused::Get(arg) != 0) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - unsigned int address_u_value = cmd::AddressingU::Get(arg); - unsigned int address_v_value = cmd::AddressingV::Get(arg); - unsigned int address_w_value = cmd::AddressingW::Get(arg); - unsigned int mag_filter_value = cmd::MagFilter::Get(arg); - unsigned int min_filter_value = cmd::MinFilter::Get(arg); - unsigned int mip_filter_value = cmd::MipFilter::Get(arg); - unsigned int max_anisotropy = cmd::MaxAnisotropy::Get(arg); - if (address_u_value >= sampler::NUM_ADDRESSING_MODE || - address_v_value >= sampler::NUM_ADDRESSING_MODE || - address_w_value >= sampler::NUM_ADDRESSING_MODE || - mag_filter_value >= sampler::NUM_FILTERING_MODE || - min_filter_value >= sampler::NUM_FILTERING_MODE || - mip_filter_value >= sampler::NUM_FILTERING_MODE || - mag_filter_value == sampler::NONE || - min_filter_value == sampler::NONE || - max_anisotropy == 0) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - } - gapi_->SetSamplerStates( - id, - static_cast<sampler::AddressingMode>(address_u_value), - static_cast<sampler::AddressingMode>(address_v_value), - static_cast<sampler::AddressingMode>(address_w_value), - static_cast<sampler::FilteringMode>(mag_filter_value), - static_cast<sampler::FilteringMode>(min_filter_value), - static_cast<sampler::FilteringMode>(mip_filter_value), - max_anisotropy); - return BufferSyncInterface::PARSE_NO_ERROR; -} - -// Decodes the SET_STENCIL_TEST command. -BufferSyncInterface::ParseError GAPIDecoder::DecodeSetStencilTest( - unsigned int arg_count, - CommandBufferEntry *args) { - namespace cmd = set_stencil_test; - if (arg_count != 2) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - Uint32 arg0 = args[0].value_uint32; - Uint32 arg1 = args[1].value_uint32; - if (cmd::Unused0::Get(arg0) != 0 || - cmd::Unused1::Get(arg1) != 0 || - cmd::Unused2::Get(arg1) != 0) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - unsigned int write_mask = cmd::WriteMask::Get(arg0); - unsigned int compare_mask = cmd::CompareMask::Get(arg0); - unsigned int ref = cmd::ReferenceValue::Get(arg0); - bool enable = cmd::Enable::Get(arg0) != 0; - bool separate_ccw = cmd::SeparateCCW::Get(arg0) != 0; - gapi_->SetStencilTest(enable, separate_ccw, write_mask, compare_mask, ref, - arg1); - return BufferSyncInterface::PARSE_NO_ERROR; -} - -// Decodes the SET_BLENDING command. -BufferSyncInterface::ParseError GAPIDecoder::DecodeSetBlending( - unsigned int arg_count, - CommandBufferEntry *args) { - namespace cmd = set_blending; - if (arg_count != 1) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - Uint32 arg = args[0].value_uint32; - bool enable = cmd::Enable::Get(arg) != 0; - bool separate_alpha = cmd::SeparateAlpha::Get(arg) != 0; - unsigned int color_eq = cmd::ColorEq::Get(arg); - unsigned int color_src = cmd::ColorSrcFunc::Get(arg); - unsigned int color_dst = cmd::ColorDstFunc::Get(arg); - unsigned int alpha_eq = cmd::AlphaEq::Get(arg); - unsigned int alpha_src = cmd::AlphaSrcFunc::Get(arg); - unsigned int alpha_dst = cmd::AlphaDstFunc::Get(arg); - if (cmd::Unused0::Get(arg) != 0 || - cmd::Unused1::Get(arg) != 0 || - color_eq >= GAPIInterface::NUM_BLEND_EQ || - color_src >= GAPIInterface::NUM_BLEND_FUNC || - color_dst >= GAPIInterface::NUM_BLEND_FUNC || - alpha_eq >= GAPIInterface::NUM_BLEND_EQ || - alpha_src >= GAPIInterface::NUM_BLEND_FUNC || - alpha_dst >= GAPIInterface::NUM_BLEND_FUNC) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; - gapi_->SetBlending(enable, - separate_alpha, - static_cast<GAPIInterface::BlendEq>(color_eq), - static_cast<GAPIInterface::BlendFunc>(color_src), - static_cast<GAPIInterface::BlendFunc>(color_dst), - static_cast<GAPIInterface::BlendEq>(alpha_eq), - static_cast<GAPIInterface::BlendFunc>(alpha_src), - static_cast<GAPIInterface::BlendFunc>(alpha_dst)); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseUnknownCommand; } void *GAPIDecoder::GetAddressAndCheckSize(unsigned int shm_id, @@ -444,426 +119,586 @@ void *GAPIDecoder::GetAddressAndCheckSize(unsigned int shm_id, return static_cast<char *>(shm_addr) + offset; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_NOOP( +BufferSyncInterface::ParseError GAPIDecoder::HandleNoop( uint32 arg_count, - const cmd::NOOP& args) { - return BufferSyncInterface::PARSE_NO_ERROR; + const cmd::Noop& args) { + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_TOKEN( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetToken( uint32 arg_count, - const cmd::SET_TOKEN& args) { + const cmd::SetToken& args) { engine_->set_token(args.token); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_BEGIN_FRAME( +BufferSyncInterface::ParseError GAPIDecoder::HandleBeginFrame( uint32 arg_count, - const cmd::BEGIN_FRAME& args) { + const cmd::BeginFrame& args) { gapi_->BeginFrame(); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_END_FRAME( +BufferSyncInterface::ParseError GAPIDecoder::HandleEndFrame( uint32 arg_count, - const cmd::END_FRAME& args) { + const cmd::EndFrame& args) { gapi_->EndFrame(); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_CLEAR( +BufferSyncInterface::ParseError GAPIDecoder::HandleClear( uint32 arg_count, - const cmd::CLEAR& args) { + const cmd::Clear& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 buffers = args.buffers; if (buffers & ~GAPIInterface::ALL_BUFFERS) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; RGBA rgba; rgba.red = args.red; rgba.green = args.green; rgba.blue = args.blue; rgba.alpha = args.alpha; gapi_->Clear(buffers, rgba, args.depth, args.stencil); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_VIEWPORT( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetViewport( uint32 arg_count, - const cmd::SET_VIEWPORT& args) { + const cmd::SetViewport& args) { gapi_->SetViewport(args.left, args.top, args.width, args.height, args.z_min, args.z_max); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_VERTEX_BUFFER( +BufferSyncInterface::ParseError GAPIDecoder::HandleCreateVertexBuffer( uint32 arg_count, - const cmd::CREATE_VERTEX_BUFFER& args) { + const cmd::CreateVertexBuffer& args) { return gapi_->CreateVertexBuffer(args.id, args.size, args.flags); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_VERTEX_BUFFER( +BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyVertexBuffer( uint32 arg_count, - const cmd::DESTROY_VERTEX_BUFFER& args) { + const cmd::DestroyVertexBuffer& args) { return gapi_->DestroyVertexBuffer(args.id); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_VERTEX_BUFFER_DATA_IMMEDIATE( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetVertexBufferDataImmediate( uint32 arg_count, - const cmd::SET_VERTEX_BUFFER_DATA_IMMEDIATE& args) { + const cmd::SetVertexBufferDataImmediate& args) { return gapi_->SetVertexBufferData(args.id, args.offset, - ImmediateSize(arg_count, args), + ImmediateDataSize(arg_count, args), AddressAfterStruct(args)); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_VERTEX_BUFFER_DATA( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetVertexBufferData( uint32 arg_count, - const cmd::SET_VERTEX_BUFFER_DATA& args) { + const cmd::SetVertexBufferData& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 size = args.size; void *data = GetAddressAndCheckSize(args.shared_memory.id, args.shared_memory.offset, size); - if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!data) return BufferSyncInterface::kParseInvalidArguments; return gapi_->SetVertexBufferData(args.id, args.offset, size, data); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_GET_VERTEX_BUFFER_DATA( +BufferSyncInterface::ParseError GAPIDecoder::HandleGetVertexBufferData( uint32 arg_count, - const cmd::GET_VERTEX_BUFFER_DATA& args) { + const cmd::GetVertexBufferData& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 size = args.size; void *data = GetAddressAndCheckSize(args.shared_memory.id, args.shared_memory.offset, size); - if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!data) return BufferSyncInterface::kParseInvalidArguments; return gapi_->GetVertexBufferData(args.id, args.offset, size, data); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_INDEX_BUFFER( +BufferSyncInterface::ParseError GAPIDecoder::HandleCreateIndexBuffer( uint32 arg_count, - const cmd::CREATE_INDEX_BUFFER& args) { + const cmd::CreateIndexBuffer& args) { return gapi_->CreateIndexBuffer(args.id, args.size, args.flags); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_INDEX_BUFFER( +BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyIndexBuffer( uint32 arg_count, - const cmd::DESTROY_INDEX_BUFFER& args) { + const cmd::DestroyIndexBuffer& args) { return gapi_->DestroyIndexBuffer(args.id); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_INDEX_BUFFER_DATA_IMMEDIATE( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetIndexBufferDataImmediate( uint32 arg_count, - const cmd::SET_INDEX_BUFFER_DATA_IMMEDIATE& args) { + const cmd::SetIndexBufferDataImmediate& args) { return gapi_->SetIndexBufferData(args.id, args.offset, - ImmediateSize(arg_count, args), + ImmediateDataSize(arg_count, args), AddressAfterStruct(args)); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_INDEX_BUFFER_DATA( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetIndexBufferData( uint32 arg_count, - const cmd::SET_INDEX_BUFFER_DATA& args) { + const cmd::SetIndexBufferData& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 size = args.size; void *data = GetAddressAndCheckSize(args.shared_memory.id, args.shared_memory.offset, size); - if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!data) return BufferSyncInterface::kParseInvalidArguments; return gapi_->SetIndexBufferData(args.id, args.offset, size, data); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_GET_INDEX_BUFFER_DATA( +BufferSyncInterface::ParseError GAPIDecoder::HandleGetIndexBufferData( uint32 arg_count, - const cmd::GET_INDEX_BUFFER_DATA& args) { + const cmd::GetIndexBufferData& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 size = args.size; void *data = GetAddressAndCheckSize(args.shared_memory.id, args.shared_memory.offset, size); - if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!data) return BufferSyncInterface::kParseInvalidArguments; return gapi_->GetIndexBufferData(args.id, args.offset, size, data); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_VERTEX_STRUCT( +BufferSyncInterface::ParseError GAPIDecoder::HandleCreateVertexStruct( uint32 arg_count, - const cmd::CREATE_VERTEX_STRUCT& args) { + const cmd::CreateVertexStruct& args) { return gapi_->CreateVertexStruct(args.id, args.input_count); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_VERTEX_STRUCT( +BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyVertexStruct( uint32 arg_count, - const cmd::DESTROY_VERTEX_STRUCT& args) { + const cmd::DestroyVertexStruct& args) { return gapi_->DestroyVertexStruct(args.id); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_VERTEX_INPUT( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetVertexInput( uint32 arg_count, - const cmd::SET_VERTEX_INPUT& args) { - // TODO(gman): fix. - return DecodeSetVertexInput(arg_count, TempHack(&args)); + const cmd::SetVertexInput& args) { + namespace cmd = set_vertex_input_cmd; + unsigned int type_stride_semantic = args.fixme4; + unsigned int semantic_index = cmd::SemanticIndex::Get(type_stride_semantic); + unsigned int semantic = cmd::Semantic::Get(type_stride_semantic); + unsigned int type = cmd::Type::Get(type_stride_semantic); + unsigned int stride = cmd::Stride::Get(type_stride_semantic); + if (semantic >= vertex_struct::NUM_SEMANTICS || + type >= vertex_struct::NUM_TYPES || stride == 0) + return BufferSyncInterface::kParseInvalidArguments; + return gapi_->SetVertexInput( + args.vertex_struct_id, args.input_index, args.vertex_buffer_id, + args.offset, stride, + static_cast<vertex_struct::Type>(type), + static_cast<vertex_struct::Semantic>(semantic), + semantic_index); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_VERTEX_STRUCT( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetVertexStruct( uint32 arg_count, - const cmd::SET_VERTEX_STRUCT& args) { + const cmd::SetVertexStruct& args) { return gapi_->SetVertexStruct(args.id); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_DRAW( +BufferSyncInterface::ParseError GAPIDecoder::HandleDraw( uint32 arg_count, - const cmd::DRAW& args) { + const cmd::Draw& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 primitive_type = args.primitive_type; if (primitive_type >= GAPIInterface::MAX_PRIMITIVE_TYPE) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; return gapi_->Draw( static_cast<GAPIInterface::PrimitiveType>(primitive_type), args.first, args.count); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_DRAW_INDEXED( +BufferSyncInterface::ParseError GAPIDecoder::HandleDrawIndexed( uint32 arg_count, - const cmd::DRAW_INDEXED& args) { + const cmd::DrawIndexed& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 primitive_type = args.primitive_type; if (primitive_type >= GAPIInterface::MAX_PRIMITIVE_TYPE) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; return gapi_->DrawIndexed( static_cast<GAPIInterface::PrimitiveType>(primitive_type), args.index_buffer_id, args.first, args.count, args.min_index, args.max_index); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_EFFECT( +BufferSyncInterface::ParseError GAPIDecoder::HandleCreateEffect( uint32 arg_count, - const cmd::CREATE_EFFECT& args) { + const cmd::CreateEffect& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 size = args.size; void *data = GetAddressAndCheckSize(args.shared_memory.id, args.shared_memory.offset, size); - if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!data) return BufferSyncInterface::kParseInvalidArguments; return gapi_->CreateEffect(args.id, size, data); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_EFFECT_IMMEDIATE( +BufferSyncInterface::ParseError GAPIDecoder::HandleCreateEffectImmediate( uint32 arg_count, - const cmd::CREATE_EFFECT_IMMEDIATE& args) { + const cmd::CreateEffectImmediate& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 size = args.size; - if (size > ImmediateSize(arg_count, args)) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + uint32 data_size = ImmediateDataSize(arg_count, args); + if (size > data_size) + return BufferSyncInterface::kParseInvalidArguments; return gapi_->CreateEffect(args.id, size, AddressAfterStruct(args)); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_EFFECT( +BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyEffect( uint32 arg_count, - const cmd::DESTROY_EFFECT& args) { + const cmd::DestroyEffect& args) { return gapi_->DestroyEffect(args.id); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_EFFECT( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetEffect( uint32 arg_count, - const cmd::SET_EFFECT& args) { + const cmd::SetEffect& args) { return gapi_->SetEffect(args.id); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_GET_PARAM_COUNT( +BufferSyncInterface::ParseError GAPIDecoder::HandleGetParamCount( uint32 arg_count, - const cmd::GET_PARAM_COUNT& args) { + const cmd::GetParamCount& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 size = args.size; void *data = GetAddressAndCheckSize(args.shared_memory.id, args.shared_memory.offset, size); - if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!data) return BufferSyncInterface::kParseInvalidArguments; return gapi_->GetParamCount(args.id, size, data); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_PARAM( +BufferSyncInterface::ParseError GAPIDecoder::HandleCreateParam( uint32 arg_count, - const cmd::CREATE_PARAM& args) { + const cmd::CreateParam& args) { return gapi_->CreateParam(args.param_id, args.effect_id, args.index); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_PARAM_BY_NAME( +BufferSyncInterface::ParseError GAPIDecoder::HandleCreateParamByName( uint32 arg_count, - const cmd::CREATE_PARAM_BY_NAME& args) { + const cmd::CreateParamByName& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 size = args.size; void *data = GetAddressAndCheckSize(args.shared_memory.id, args.shared_memory.offset, size); - if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!data) return BufferSyncInterface::kParseInvalidArguments; return gapi_->CreateParamByName(args.param_id, args.effect_id, size, data); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_PARAM_BY_NAME_IMMEDIATE( +BufferSyncInterface::ParseError GAPIDecoder::HandleCreateParamByNameImmediate( uint32 arg_count, - const cmd::CREATE_PARAM_BY_NAME_IMMEDIATE& args) { + const cmd::CreateParamByNameImmediate& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 size = args.size; - if (size > ImmediateSize(arg_count, args)) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + uint32 data_size = ImmediateDataSize(arg_count, args); + if (size > data_size) + return BufferSyncInterface::kParseInvalidArguments; return gapi_->CreateParamByName(args.param_id, args.effect_id, size, AddressAfterStruct(args)); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_PARAM( +BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyParam( uint32 arg_count, - const cmd::DESTROY_PARAM& args) { + const cmd::DestroyParam& args) { return gapi_->DestroyParam(args.id); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_PARAM_DATA( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetParamData( uint32 arg_count, - const cmd::SET_PARAM_DATA& args) { + const cmd::SetParamData& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 size = args.size; void *data = GetAddressAndCheckSize(args.shared_memory.id, args.shared_memory.offset, size); - if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!data) return BufferSyncInterface::kParseInvalidArguments; return gapi_->SetParamData(args.id, size, data); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_PARAM_DATA_IMMEDIATE( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetParamDataImmediate( uint32 arg_count, - const cmd::SET_PARAM_DATA_IMMEDIATE& args) { + const cmd::SetParamDataImmediate& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 size = args.size; - if (size > ImmediateSize(arg_count, args)) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + uint32 data_size = ImmediateDataSize(arg_count, args); + if (size > data_size) + return BufferSyncInterface::kParseInvalidArguments; return gapi_->SetParamData(args.id, size, AddressAfterStruct(args)); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_GET_PARAM_DESC( +BufferSyncInterface::ParseError GAPIDecoder::HandleGetParamDesc( uint32 arg_count, - const cmd::GET_PARAM_DESC& args) { + const cmd::GetParamDesc& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 size = args.size; void *data = GetAddressAndCheckSize(args.shared_memory.id, args.shared_memory.offset, size); - if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!data) return BufferSyncInterface::kParseInvalidArguments; return gapi_->GetParamDesc(args.id, size, data); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_GET_STREAM_COUNT( +BufferSyncInterface::ParseError GAPIDecoder::HandleGetStreamCount( uint32 arg_count, - const cmd::GET_STREAM_COUNT& args) { + const cmd::GetStreamCount& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 size = args.size; void *data = GetAddressAndCheckSize(args.shared_memory.id, args.shared_memory.offset, size); - if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!data) return BufferSyncInterface::kParseInvalidArguments; return gapi_->GetStreamCount(args.id, size, data); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_GET_STREAM_DESC( +BufferSyncInterface::ParseError GAPIDecoder::HandleGetStreamDesc( uint32 arg_count, - const cmd::GET_STREAM_DESC& args) { + const cmd::GetStreamDesc& args) { // Pull out some values so they can't be changed by another thread after we've // validated them. uint32 size = args.size; void *data = GetAddressAndCheckSize(args.shared_memory.id, args.shared_memory.offset, size); - if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!data) return BufferSyncInterface::kParseInvalidArguments; return gapi_->GetStreamDesc(args.id, args.index, size, data); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_TEXTURE( +BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyTexture( uint32 arg_count, - const cmd::DESTROY_TEXTURE& args) { + const cmd::DestroyTexture& args) { return gapi_->DestroyTexture(args.id); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_TEXTURE_2D( - uint32 arg_count, - const cmd::CREATE_TEXTURE_2D& args) { - // TODO(gman): fix. - return DecodeCreateTexture2D(arg_count, TempHack(&args)); -} - -BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_TEXTURE_3D( - uint32 arg_count, - const cmd::CREATE_TEXTURE_3D& args) { - // TODO(gman): fix. - return DecodeCreateTexture3D(arg_count, TempHack(&args)); -} - -BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_TEXTURE_CUBE( - uint32 arg_count, - const cmd::CREATE_TEXTURE_CUBE& args) { - // TODO(gman): fix. - return DecodeCreateTextureCube(arg_count, TempHack(&args)); -} - -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_TEXTURE_DATA( - uint32 arg_count, - const cmd::SET_TEXTURE_DATA& args) { - // TODO(gman): fix. - return DecodeSetTextureData(arg_count, TempHack(&args)); -} - -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_TEXTURE_DATA_IMMEDIATE( - uint32 arg_count, - const cmd::SET_TEXTURE_DATA_IMMEDIATE& args) { - // TODO(gman): fix. - return DecodeSetTextureDataImmediate(arg_count, TempHack(&args)); -} - -BufferSyncInterface::ParseError GAPIDecoder::Handle_GET_TEXTURE_DATA( +BufferSyncInterface::ParseError GAPIDecoder::HandleCreateTexture2d( uint32 arg_count, - const cmd::GET_TEXTURE_DATA& args) { - // TODO(gman): fix. - return DecodeGetTextureData(arg_count, TempHack(&args)); + const cmd::CreateTexture2d& args) { + namespace cmd = create_texture_2d_cmd; + unsigned int width_height = args.fixme1; + unsigned int levels_format_flags = args.fixme2; + unsigned int width = cmd::Width::Get(width_height); + unsigned int height = cmd::Height::Get(width_height); + unsigned int levels = cmd::Levels::Get(levels_format_flags); + unsigned int unused = cmd::Unused::Get(levels_format_flags); + unsigned int format = cmd::Format::Get(levels_format_flags); + unsigned int flags = cmd::Flags::Get(levels_format_flags); + unsigned int max_levels = + 1 + base::bits::Log2Ceiling(std::max(width, height)); + if ((width == 0) || (height == 0) || (levels > max_levels) || + (unused != 0) || (format >= texture::NUM_FORMATS) || (levels == 0)) + return BufferSyncInterface::kParseInvalidArguments; + bool enable_render_surfaces = !!flags; + return gapi_->CreateTexture2D(args.texture_id, width, height, levels, + static_cast<texture::Format>(format), flags, + enable_render_surfaces); +} + +BufferSyncInterface::ParseError GAPIDecoder::HandleCreateTexture3d( + uint32 arg_count, + const cmd::CreateTexture3d& args) { + namespace cmd = create_texture_3d_cmd; + unsigned int width_height = args.fixme1; + unsigned int depth_unused = args.fixme2; + unsigned int levels_format_flags = args.fixme3; + unsigned int width = cmd::Width::Get(width_height); + unsigned int height = cmd::Height::Get(width_height); + unsigned int depth = cmd::Depth::Get(depth_unused); + unsigned int unused1 = cmd::Unused1::Get(depth_unused); + unsigned int levels = cmd::Levels::Get(levels_format_flags); + unsigned int unused2 = cmd::Unused2::Get(levels_format_flags); + unsigned int format = cmd::Format::Get(levels_format_flags); + unsigned int flags = cmd::Flags::Get(levels_format_flags); + unsigned int max_levels = + 1 + base::bits::Log2Ceiling(std::max(depth, std::max(width, height))); + if ((width == 0) || (height == 0) || (depth == 0) || + (levels > max_levels) || (unused1 != 0) || (unused2 != 0) || + (format >= texture::NUM_FORMATS) || (levels == 0)) + return BufferSyncInterface::kParseInvalidArguments; + bool enable_render_surfaces = !!flags; + return gapi_->CreateTexture3D(args.texture_id, width, height, depth, levels, + static_cast<texture::Format>(format), flags, + enable_render_surfaces); +} + +BufferSyncInterface::ParseError GAPIDecoder::HandleCreateTextureCube( + uint32 arg_count, + const cmd::CreateTextureCube& args) { + namespace cmd = create_texture_cube_cmd; + unsigned int side_unused = args.edge_length; + unsigned int levels_format_flags = args.fixme2; + unsigned int side = cmd::Side::Get(side_unused); + unsigned int unused1 = cmd::Unused1::Get(side_unused); + unsigned int levels = cmd::Levels::Get(levels_format_flags); + unsigned int unused2 = cmd::Unused2::Get(levels_format_flags); + unsigned int format = cmd::Format::Get(levels_format_flags); + unsigned int flags = cmd::Flags::Get(levels_format_flags); + unsigned int max_levels = 1 + base::bits::Log2Ceiling(side); + if ((side == 0) || (levels > max_levels) || (unused1 != 0) || + (unused2 != 0) || (format >= texture::NUM_FORMATS) || (levels == 0)) + return BufferSyncInterface::kParseInvalidArguments; + bool enable_render_surfaces = !!flags; + return gapi_->CreateTextureCube(args.texture_id, side, levels, + static_cast<texture::Format>(format), + flags, enable_render_surfaces); +} + +BufferSyncInterface::ParseError GAPIDecoder::HandleSetTextureData( + uint32 arg_count, + const cmd::SetTextureData& args) { + namespace cmd = set_texture_data_cmd; + unsigned int x_y = args.fixme1; + unsigned int width_height = args.fixme2; + unsigned int z_depth = args.fixme3; + unsigned int level_face = args.fixme4; + unsigned int size = args.size; + unsigned int x = cmd::X::Get(x_y); + unsigned int y = cmd::Y::Get(x_y); + unsigned int width = cmd::Width::Get(width_height); + unsigned int height = cmd::Height::Get(width_height); + unsigned int z = cmd::Z::Get(z_depth); + unsigned int depth = cmd::Depth::Get(z_depth); + unsigned int level = cmd::Level::Get(level_face); + unsigned int face = cmd::Face::Get(level_face); + unsigned int unused = cmd::Unused::Get(level_face); + const void *data = GetAddressAndCheckSize(args.shared_memory.id, + args.shared_memory.offset, size); + if (face >= 6 || unused != 0 || !data) + return BufferSyncInterface::kParseInvalidArguments; + return gapi_->SetTextureData( + args.texture_id, x, y, z, width, height, depth, level, + static_cast<texture::Face>(face), args.row_pitch, + args.slice_pitch, size, data); +} + +BufferSyncInterface::ParseError GAPIDecoder::HandleSetTextureDataImmediate( + uint32 arg_count, + const cmd::SetTextureDataImmediate& args) { + namespace cmd = set_texture_data_immediate_cmd; + unsigned int x_y = args.fixme1; + unsigned int width_height = args.fixme2; + unsigned int z_depth = args.fixme3; + unsigned int level_face = args.fixme4; + unsigned int size = args.size; + unsigned int x = cmd::X::Get(x_y); + unsigned int y = cmd::Y::Get(x_y); + unsigned int width = cmd::Width::Get(width_height); + unsigned int height = cmd::Height::Get(width_height); + unsigned int z = cmd::Z::Get(z_depth); + unsigned int depth = cmd::Depth::Get(z_depth); + unsigned int level = cmd::Level::Get(level_face); + unsigned int face = cmd::Face::Get(level_face); + unsigned int unused = cmd::Unused::Get(level_face); + uint32 data_size = ImmediateDataSize(arg_count, args); + if (face >= 6 || unused != 0 || + size > data_size) + return BufferSyncInterface::kParseInvalidArguments; + return gapi_->SetTextureData( + args.texture_id, x, y, z, width, height, depth, level, + static_cast<texture::Face>(face), args.row_pitch, + args.slice_pitch, size, AddressAfterStruct(args)); +} + +BufferSyncInterface::ParseError GAPIDecoder::HandleGetTextureData( + uint32 arg_count, + const cmd::GetTextureData& args) { + namespace cmd = get_texture_data_cmd; + unsigned int x_y = args.fixme1; + unsigned int width_height = args.fixme2; + unsigned int z_depth = args.fixme3; + unsigned int level_face = args.fixme4; + unsigned int size = args.size; + unsigned int x = cmd::X::Get(x_y); + unsigned int y = cmd::Y::Get(x_y); + unsigned int width = cmd::Width::Get(width_height); + unsigned int height = cmd::Height::Get(width_height); + unsigned int z = cmd::Z::Get(z_depth); + unsigned int depth = cmd::Depth::Get(z_depth); + unsigned int level = cmd::Level::Get(level_face); + unsigned int face = cmd::Face::Get(level_face); + unsigned int unused = cmd::Unused::Get(level_face); + void *data = GetAddressAndCheckSize(args.shared_memory.id, + args.shared_memory.offset, size); + if (face >= 6 || unused != 0 || !data) + return BufferSyncInterface::kParseInvalidArguments; + return gapi_->GetTextureData( + args.texture_id, x, y, z, width, height, depth, level, + static_cast<texture::Face>(face), args.row_pitch, + args.slice_pitch, size, data); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_SAMPLER( +BufferSyncInterface::ParseError GAPIDecoder::HandleCreateSampler( uint32 arg_count, - const cmd::CREATE_SAMPLER& args) { + const cmd::CreateSampler& args) { return gapi_->CreateSampler(args.id); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_SAMPLER( +BufferSyncInterface::ParseError GAPIDecoder::HandleDestroySampler( uint32 arg_count, - const cmd::DESTROY_SAMPLER& args) { + const cmd::DestroySampler& args) { return gapi_->DestroySampler(args.id); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_SAMPLER_STATES( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetSamplerStates( uint32 arg_count, - const cmd::SET_SAMPLER_STATES& args) { - // TODO(gman): fix. - return DecodeSetSamplerStates(arg_count, TempHack(&args)); + const cmd::SetSamplerStates& args) { + namespace cmd = set_sampler_states; + Uint32 arg = args.fixme1; + if (cmd::Unused::Get(arg) != 0) + return BufferSyncInterface::kParseInvalidArguments; + unsigned int address_u_value = cmd::AddressingU::Get(arg); + unsigned int address_v_value = cmd::AddressingV::Get(arg); + unsigned int address_w_value = cmd::AddressingW::Get(arg); + unsigned int mag_filter_value = cmd::MagFilter::Get(arg); + unsigned int min_filter_value = cmd::MinFilter::Get(arg); + unsigned int mip_filter_value = cmd::MipFilter::Get(arg); + unsigned int max_anisotropy = cmd::MaxAnisotropy::Get(arg); + if (address_u_value >= sampler::NUM_ADDRESSING_MODE || + address_v_value >= sampler::NUM_ADDRESSING_MODE || + address_w_value >= sampler::NUM_ADDRESSING_MODE || + mag_filter_value >= sampler::NUM_FILTERING_MODE || + min_filter_value >= sampler::NUM_FILTERING_MODE || + mip_filter_value >= sampler::NUM_FILTERING_MODE || + mag_filter_value == sampler::NONE || + min_filter_value == sampler::NONE || + max_anisotropy == 0) { + return BufferSyncInterface::kParseInvalidArguments; + } + gapi_->SetSamplerStates( + args.id, + static_cast<sampler::AddressingMode>(address_u_value), + static_cast<sampler::AddressingMode>(address_v_value), + static_cast<sampler::AddressingMode>(address_w_value), + static_cast<sampler::FilteringMode>(mag_filter_value), + static_cast<sampler::FilteringMode>(min_filter_value), + static_cast<sampler::FilteringMode>(mip_filter_value), + max_anisotropy); + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_SAMPLER_BORDER_COLOR( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetSamplerBorderColor( uint32 arg_count, - const cmd::SET_SAMPLER_BORDER_COLOR& args) { + const cmd::SetSamplerBorderColor& args) { RGBA rgba; rgba.red = args.red; rgba.green = args.green; @@ -872,19 +707,19 @@ BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_SAMPLER_BORDER_COLOR( return gapi_->SetSamplerBorderColor(args.id, rgba); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_SAMPLER_TEXTURE( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetSamplerTexture( uint32 arg_count, - const cmd::SET_SAMPLER_TEXTURE& args) { + const cmd::SetSamplerTexture& args) { return gapi_->SetSamplerTexture(args.id, args.texture_id); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_SCISSOR( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetScissor( uint32 arg_count, - const cmd::SET_SCISSOR& args) { + const cmd::SetScissor& args) { namespace cmd = set_scissor; Uint32 x_y_enable = args.fixme0; if (cmd::Unused::Get(x_y_enable) != 0) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; unsigned int x = cmd::X::Get(x_y_enable); unsigned int y = cmd::Y::Get(x_y_enable); bool enable = cmd::Enable::Get(x_y_enable) != 0; @@ -892,32 +727,32 @@ BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_SCISSOR( unsigned int width = cmd::Width::Get(width_height); unsigned int height = cmd::Height::Get(width_height); gapi_->SetScissor(enable, x, y, width, height); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_POLYGON_OFFSET( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetPolygonOffset( uint32 arg_count, - const cmd::SET_POLYGON_OFFSET& args) { + const cmd::SetPolygonOffset& args) { gapi_->SetPolygonOffset(args.slope_factor, args.units); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_POINT_LINE_RASTER( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetPointLineRaster( uint32 arg_count, - const cmd::SET_POINT_LINE_RASTER& args) { + const cmd::SetPointLineRaster& args) { namespace cmd = set_point_line_raster; Uint32 enables = args.fixme0; if (cmd::Unused::Get(enables) != 0) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; bool line_smooth = !!cmd::LineSmoothEnable::Get(enables); bool point_sprite = !!cmd::PointSpriteEnable::Get(enables); gapi_->SetPointLineRaster(line_smooth, point_sprite, args.point_size); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_POLYGON_RASTER( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetPolygonRaster( uint32 arg_count, - const cmd::SET_POLYGON_RASTER& args) { + const cmd::SetPolygonRaster& args) { namespace cmd = set_polygon_raster; Uint32 fill_cull = args.fixme0; unsigned int fill_value = cmd::FillMode::Get(fill_cull); @@ -925,20 +760,20 @@ BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_POLYGON_RASTER( if (cmd::Unused::Get(fill_cull) != 0 || fill_value >= GAPIInterface::NUM_POLYGON_MODE || cull_value >= GAPIInterface::NUM_FACE_CULL_MODE) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; gapi_->SetPolygonRaster( static_cast<GAPIInterface::PolygonMode>(fill_value), static_cast<GAPIInterface::FaceCullMode>(cull_value)); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_ALPHA_TEST( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetAlphaTest( uint32 arg_count, - const cmd::SET_ALPHA_TEST& args) { + const cmd::SetAlphaTest& args) { namespace cmd = set_alpha_test; Uint32 func_enable = args.fixme0; if (cmd::Unused::Get(func_enable) != 0) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; // Check that the bitmask get cannot generate values outside of the // allowed range. COMPILE_ASSERT(cmd::Func::kMask < GAPIInterface::NUM_COMPARISON, @@ -947,16 +782,16 @@ BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_ALPHA_TEST( static_cast<GAPIInterface::Comparison>(cmd::Func::Get(func_enable)); bool enable = cmd::Enable::Get(func_enable) != 0; gapi_->SetAlphaTest(enable, args.value, comp); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_DEPTH_TEST( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetDepthTest( uint32 arg_count, - const cmd::SET_DEPTH_TEST& args) { + const cmd::SetDepthTest& args) { namespace cmd = set_depth_test; Uint32 func_enable = args.fixme0; if (cmd::Unused::Get(func_enable) != 0) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; // Check that the bitmask get cannot generate values outside of the // allowed range. COMPILE_ASSERT(cmd::Func::kMask < GAPIInterface::NUM_COMPARISON, @@ -966,53 +801,93 @@ BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_DEPTH_TEST( bool write_enable = cmd::WriteEnable::Get(func_enable) != 0; bool enable = cmd::Enable::Get(func_enable) != 0; gapi_->SetDepthTest(enable, write_enable, comp); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_STENCIL_TEST( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetStencilTest( uint32 arg_count, - const cmd::SET_STENCIL_TEST& args) { - // TODO(gman): fix. - return DecodeSetStencilTest(arg_count, TempHack(&args)); + const cmd::SetStencilTest& args) { + namespace cmd = set_stencil_test; + Uint32 arg0 = args.fixme0; + Uint32 arg1 = args.fixme1; + if (cmd::Unused0::Get(arg0) != 0 || + cmd::Unused1::Get(arg1) != 0 || + cmd::Unused2::Get(arg1) != 0) + return BufferSyncInterface::kParseInvalidArguments; + unsigned int write_mask = cmd::WriteMask::Get(arg0); + unsigned int compare_mask = cmd::CompareMask::Get(arg0); + unsigned int ref = cmd::ReferenceValue::Get(arg0); + bool enable = cmd::Enable::Get(arg0) != 0; + bool separate_ccw = cmd::SeparateCCW::Get(arg0) != 0; + gapi_->SetStencilTest(enable, separate_ccw, write_mask, compare_mask, ref, + arg1); + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_COLOR_WRITE( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetColorWrite( uint32 arg_count, - const cmd::SET_COLOR_WRITE& args) { + const cmd::SetColorWrite& args) { namespace cmd = set_color_write; Uint32 enables = args.flags; if (cmd::Unused::Get(enables) != 0) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; bool red = cmd::RedMask::Get(enables) != 0; bool green = cmd::GreenMask::Get(enables) != 0; bool blue = cmd::BlueMask::Get(enables) != 0; bool alpha = cmd::AlphaMask::Get(enables) != 0; bool dither = cmd::DitherEnable::Get(enables) != 0; gapi_->SetColorWrite(red, green, blue, alpha, dither); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_BLENDING( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetBlending( uint32 arg_count, - const cmd::SET_BLENDING& args) { - return DecodeSetBlending(arg_count, TempHack(&args)); + const cmd::SetBlending& args) { + namespace cmd = set_blending; + Uint32 arg = args.fixme0; + bool enable = cmd::Enable::Get(arg) != 0; + bool separate_alpha = cmd::SeparateAlpha::Get(arg) != 0; + unsigned int color_eq = cmd::ColorEq::Get(arg); + unsigned int color_src = cmd::ColorSrcFunc::Get(arg); + unsigned int color_dst = cmd::ColorDstFunc::Get(arg); + unsigned int alpha_eq = cmd::AlphaEq::Get(arg); + unsigned int alpha_src = cmd::AlphaSrcFunc::Get(arg); + unsigned int alpha_dst = cmd::AlphaDstFunc::Get(arg); + if (cmd::Unused0::Get(arg) != 0 || + cmd::Unused1::Get(arg) != 0 || + color_eq >= GAPIInterface::NUM_BLEND_EQ || + color_src >= GAPIInterface::NUM_BLEND_FUNC || + color_dst >= GAPIInterface::NUM_BLEND_FUNC || + alpha_eq >= GAPIInterface::NUM_BLEND_EQ || + alpha_src >= GAPIInterface::NUM_BLEND_FUNC || + alpha_dst >= GAPIInterface::NUM_BLEND_FUNC) + return BufferSyncInterface::kParseInvalidArguments; + gapi_->SetBlending(enable, + separate_alpha, + static_cast<GAPIInterface::BlendEq>(color_eq), + static_cast<GAPIInterface::BlendFunc>(color_src), + static_cast<GAPIInterface::BlendFunc>(color_dst), + static_cast<GAPIInterface::BlendEq>(alpha_eq), + static_cast<GAPIInterface::BlendFunc>(alpha_src), + static_cast<GAPIInterface::BlendFunc>(alpha_dst)); + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_BLENDING_COLOR( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetBlendingColor( uint32 arg_count, - const cmd::SET_BLENDING_COLOR& args) { + const cmd::SetBlendingColor& args) { RGBA rgba; rgba.red = args.red; rgba.green = args.green; rgba.blue = args.blue; rgba.alpha = args.alpha; gapi_->SetBlendingColor(rgba); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } -BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_RENDER_SURFACE( +BufferSyncInterface::ParseError GAPIDecoder::HandleCreateRenderSurface( uint32 arg_count, - const cmd::CREATE_RENDER_SURFACE& args) { + const cmd::CreateRenderSurface& args) { namespace cmd = create_render_surface_cmd; unsigned int width_height = args.fixme1; unsigned int width = cmd::Width::Get(width_height); @@ -1024,39 +899,39 @@ BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_RENDER_SURFACE( side, args.texture_id); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_RENDER_SURFACE( +BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyRenderSurface( uint32 arg_count, - const cmd::DESTROY_RENDER_SURFACE& args) { + const cmd::DestroyRenderSurface& args) { return gapi_->DestroyRenderSurface(args.id); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_DEPTH_SURFACE( +BufferSyncInterface::ParseError GAPIDecoder::HandleCreateDepthSurface( uint32 arg_count, - const cmd::CREATE_DEPTH_SURFACE& args) { - namespace cmd = create_render_surface_cmd; + const cmd::CreateDepthSurface& args) { + namespace cmd = create_depth_surface_cmd; unsigned int width_height = args.fixme1; unsigned int width = cmd::Width::Get(width_height); unsigned int height = cmd::Height::Get(width_height); return gapi_->CreateDepthSurface(args.id, width, height); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_DEPTH_SURFACE( +BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyDepthSurface( uint32 arg_count, - const cmd::DESTROY_DEPTH_SURFACE& args) { + const cmd::DestroyDepthSurface& args) { return gapi_->DestroyDepthSurface(args.id); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_RENDER_SURFACE( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetRenderSurface( uint32 arg_count, - const cmd::SET_RENDER_SURFACE& args) { + const cmd::SetRenderSurface& args) { return gapi_->SetRenderSurface(args.render_surface_id, args.depth_surface_id); } -BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_BACK_SURFACES( +BufferSyncInterface::ParseError GAPIDecoder::HandleSetBackSurfaces( uint32 arg_count, - const cmd::SET_BACK_SURFACES& args) { + const cmd::SetBackSurfaces& args) { gapi_->SetBackSurfaces(); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } } // namespace command_buffer diff --git a/o3d/command_buffer/service/cross/gapi_decoder.h b/o3d/command_buffer/service/cross/gapi_decoder.h index 67b1806..a9af75c 100644 --- a/o3d/command_buffer/service/cross/gapi_decoder.h +++ b/o3d/command_buffer/service/cross/gapi_decoder.h @@ -52,14 +52,8 @@ class GAPIDecoder : public AsyncAPIInterface { explicit GAPIDecoder(GAPIInterface *gapi) : gapi_(gapi), engine_(NULL) {} virtual ~GAPIDecoder() {} - // Executes a command. - // Parameters: - // command: the command index. - // arg_count: the number of CommandBufferEntry arguments. - // args: the arguments. - // Returns: - // BufferSyncInterface::NO_ERROR if no error was found, one of - // BufferSyncInterface::ParseError otherwise. + + // Overridden from AsyncAPIInterface. virtual ParseError DoCommand(unsigned int command, unsigned int arg_count, const void* args); @@ -68,46 +62,6 @@ class GAPIDecoder : public AsyncAPIInterface { // to. void set_engine(CommandBufferEngine *engine) { engine_ = engine; } private: - // Decodes the SET_VERTEX_INPUT command. - ParseError DecodeSetVertexInput(unsigned int arg_count, - CommandBufferEntry *args); - - // Decodes the CREATE_TEXTURE_2D command. - ParseError DecodeCreateTexture2D(unsigned int arg_count, - CommandBufferEntry *args); - - // Decodes the CREATE_TEXTURE_3D command. - ParseError DecodeCreateTexture3D(unsigned int arg_count, - CommandBufferEntry *args); - - // Decodes the CREATE_TEXTURE_CUBE command. - ParseError DecodeCreateTextureCube(unsigned int arg_count, - CommandBufferEntry *args); - - // Decodes the SET_TEXTURE_DATA command. - ParseError DecodeSetTextureData(unsigned int arg_count, - CommandBufferEntry *args); - - // Decodes the SET_TEXTURE_DATA_IMMEDIATE command. - ParseError DecodeSetTextureDataImmediate(unsigned int arg_count, - CommandBufferEntry *args); - - // Decodes the GET_TEXTURE_DATA command. - ParseError DecodeGetTextureData(unsigned int arg_count, - CommandBufferEntry *args); - - // Decodes the SET_SAMPLER_STATES command. - ParseError DecodeSetSamplerStates(unsigned int arg_count, - CommandBufferEntry *args); - - // Decodes the SET_STENCIL_TEST command. - ParseError DecodeSetStencilTest(unsigned int arg_count, - CommandBufferEntry *args); - - // Decodes the SET_BLENDING command. - ParseError DecodeSetBlending(unsigned int arg_count, - CommandBufferEntry *args); - // Gets the address of shared memory data, given a shared memory ID and an // offset. Also checks that the size is consistent with the shared memory // size. @@ -125,7 +79,7 @@ class GAPIDecoder : public AsyncAPIInterface { // Generate a member function prototype for each command in an automated and // typesafe way. #define O3D_COMMAND_BUFFER_CMD_OP(name) \ - ParseError Handle_ ## name( \ + ParseError Handle ## name( \ unsigned int arg_count, \ const cmd::name& args); \ diff --git a/o3d/command_buffer/service/cross/gl/effect_gl.cc b/o3d/command_buffer/service/cross/gl/effect_gl.cc index c2c49e3..3c0baf6 100644 --- a/o3d/command_buffer/service/cross/gl/effect_gl.cc +++ b/o3d/command_buffer/service/cross/gl/effect_gl.cc @@ -720,27 +720,27 @@ BufferSyncInterface::ParseError GAPIGL::CreateEffect(ResourceID id, &vertex_program_entry, &fragment_program_entry, &effect_code)) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } EffectGL * effect = EffectGL::Create(this, effect_code, vertex_program_entry, fragment_program_entry); - if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!effect) return BufferSyncInterface::kParseInvalidArguments; effects_.Assign(id, effect); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPIGL::DestroyEffect(ResourceID id) { if (id == current_effect_id_) DirtyEffect(); return effects_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPIGL::SetEffect(ResourceID id) { DirtyEffect(); current_effect_id_ = id; - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPIGL::GetParamCount(ResourceID id, @@ -748,20 +748,20 @@ BufferSyncInterface::ParseError GAPIGL::GetParamCount(ResourceID id, void *data) { EffectGL *effect = effects_.Get(id); if (!effect || size < sizeof(Uint32)) // NOLINT - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; *static_cast<Uint32 *>(data) = effect->GetParamCount(); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPIGL::CreateParam(ResourceID param_id, ResourceID effect_id, unsigned int index) { EffectGL *effect = effects_.Get(effect_id); - if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!effect) return BufferSyncInterface::kParseInvalidArguments; EffectParamGL *param = effect->CreateParam(index); - if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!param) return BufferSyncInterface::kParseInvalidArguments; effect_params_.Assign(param_id, param); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPIGL::CreateParamByName(ResourceID param_id, @@ -769,38 +769,38 @@ BufferSyncInterface::ParseError GAPIGL::CreateParamByName(ResourceID param_id, unsigned int size, const void *name) { EffectGL *effect = effects_.Get(effect_id); - if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!effect) return BufferSyncInterface::kParseInvalidArguments; std::string string_name(static_cast<const char *>(name), size); EffectParamGL *param = effect->CreateParamByName(string_name.c_str()); - if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!param) return BufferSyncInterface::kParseInvalidArguments; effect_params_.Assign(param_id, param); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPIGL::DestroyParam(ResourceID id) { return effect_params_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPIGL::SetParamData(ResourceID id, unsigned int size, const void *data) { EffectParamGL *param = effect_params_.Get(id); - if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!param) return BufferSyncInterface::kParseInvalidArguments; return param->SetData(this, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPIGL::GetParamDesc(ResourceID id, unsigned int size, void *data) { EffectParamGL *param = effect_params_.Get(id); - if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!param) return BufferSyncInterface::kParseInvalidArguments; return param->GetDesc(size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPIGL::GetStreamCount( @@ -809,9 +809,9 @@ BufferSyncInterface::ParseError GAPIGL::GetStreamCount( void *data) { EffectGL *effect = effects_.Get(id); if (!effect || size < sizeof(Uint32)) // NOLINT - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; *static_cast<Uint32 *>(data) = effect->GetStreamCount(); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPIGL::GetStreamDesc(ResourceID id, @@ -819,10 +819,10 @@ BufferSyncInterface::ParseError GAPIGL::GetStreamDesc(ResourceID id, unsigned int size, void *data) { EffectGL *effect = effects_.Get(id); - if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!effect) return BufferSyncInterface::kParseInvalidArguments; return effect->GetStreamDesc(index, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } // If the current effect is valid, call End on it, and tag for revalidation. diff --git a/o3d/command_buffer/service/cross/gl/geometry_gl.cc b/o3d/command_buffer/service/cross/gl/geometry_gl.cc index c6e1dc8..58bf819 100644 --- a/o3d/command_buffer/service/cross/gl/geometry_gl.cc +++ b/o3d/command_buffer/service/cross/gl/geometry_gl.cc @@ -311,13 +311,13 @@ BufferSyncInterface::ParseError GAPIGL::CreateVertexBuffer(ResourceID id, VertexBufferGL *vertex_buffer = new VertexBufferGL(size, flags); vertex_buffer->Create(); vertex_buffers_.Assign(id, vertex_buffer); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPIGL::DestroyVertexBuffer(ResourceID id) { return vertex_buffers_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPIGL::SetVertexBufferData(ResourceID id, @@ -325,10 +325,10 @@ BufferSyncInterface::ParseError GAPIGL::SetVertexBufferData(ResourceID id, unsigned int size, const void *data) { VertexBufferGL *vertex_buffer = vertex_buffers_.Get(id); - if (!vertex_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!vertex_buffer) return BufferSyncInterface::kParseInvalidArguments; return vertex_buffer->SetData(offset, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPIGL::GetVertexBufferData(ResourceID id, @@ -336,10 +336,10 @@ BufferSyncInterface::ParseError GAPIGL::GetVertexBufferData(ResourceID id, unsigned int size, void *data) { VertexBufferGL *vertex_buffer = vertex_buffers_.Get(id); - if (!vertex_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!vertex_buffer) return BufferSyncInterface::kParseInvalidArguments; return vertex_buffer->GetData(offset, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPIGL::CreateIndexBuffer(ResourceID id, @@ -348,13 +348,13 @@ BufferSyncInterface::ParseError GAPIGL::CreateIndexBuffer(ResourceID id, IndexBufferGL *index_buffer = new IndexBufferGL(size, flags); index_buffer->Create(); index_buffers_.Assign(id, index_buffer); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPIGL::DestroyIndexBuffer(ResourceID id) { return index_buffers_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPIGL::SetIndexBufferData(ResourceID id, @@ -362,10 +362,10 @@ BufferSyncInterface::ParseError GAPIGL::SetIndexBufferData(ResourceID id, unsigned int size, const void *data) { IndexBufferGL *index_buffer = index_buffers_.Get(id); - if (!index_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments; return index_buffer->SetData(offset, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPIGL::GetIndexBufferData(ResourceID id, @@ -373,10 +373,10 @@ BufferSyncInterface::ParseError GAPIGL::GetIndexBufferData(ResourceID id, unsigned int size, void *data) { IndexBufferGL *index_buffer = index_buffers_.Get(id); - if (!index_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments; return index_buffer->GetData(offset, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPIGL::CreateVertexStruct( @@ -385,14 +385,14 @@ BufferSyncInterface::ParseError GAPIGL::CreateVertexStruct( if (id == current_vertex_struct_) validate_streams_ = true; VertexStructGL *vertex_struct = new VertexStructGL(input_count); vertex_structs_.Assign(id, vertex_struct); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPIGL::DestroyVertexStruct(ResourceID id) { if (id == current_vertex_struct_) validate_streams_ = true; return vertex_structs_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPIGL::SetVertexInput( @@ -407,22 +407,22 @@ BufferSyncInterface::ParseError GAPIGL::SetVertexInput( switch (semantic) { case vertex_struct::POSITION: if (semantic_index != 0) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } break; case vertex_struct::NORMAL: if (semantic_index != 0) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } break; case vertex_struct::COLOR: if (semantic_index >= 2) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } break; case vertex_struct::TEX_COORD: if (semantic_index >= 8) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } break; default: @@ -432,16 +432,16 @@ BufferSyncInterface::ParseError GAPIGL::SetVertexInput( if (vertex_buffer_id == current_vertex_struct_) validate_streams_ = true; VertexStructGL *vertex_struct = vertex_structs_.Get(vertex_struct_id); if (!vertex_struct || input_index >= vertex_struct->count()) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; vertex_struct->SetInput(input_index, vertex_buffer_id, offset, stride, type, semantic, semantic_index); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPIGL::SetVertexStruct(ResourceID id) { current_vertex_struct_ = id; validate_streams_ = true; - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } bool GAPIGL::ValidateStreams() { @@ -497,20 +497,20 @@ BufferSyncInterface::ParseError GAPIGL::Draw(PrimitiveType primitive_type, unsigned int first, unsigned int count) { if (validate_effect_ && !ValidateEffect()) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } DCHECK(current_effect_); if (validate_streams_ && !ValidateStreams()) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } GLenum gl_mode = GL_POINTS; PrimitiveTypeToGL(primitive_type, &gl_mode, &count); if (first + count > max_vertices_) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } glDrawArrays(gl_mode, first, count); CHECK_GL_ERROR(); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPIGL::DrawIndexed( @@ -521,16 +521,16 @@ BufferSyncInterface::ParseError GAPIGL::DrawIndexed( unsigned int min_index, unsigned int max_index) { IndexBufferGL *index_buffer = index_buffers_.Get(index_buffer_id); - if (!index_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments; if (validate_effect_ && !ValidateEffect()) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } DCHECK(current_effect_); if (validate_streams_ && !ValidateStreams()) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } if ((min_index >= max_vertices_) || (max_index > max_vertices_)) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } GLenum gl_mode = GL_POINTS; PrimitiveTypeToGL(primitive_type, &gl_mode, &count); @@ -541,12 +541,12 @@ BufferSyncInterface::ParseError GAPIGL::DrawIndexed( sizeof(GLuint) : sizeof(GLushort); // NOLINT GLuint offset = first * index_size; if (offset + count * index_size > index_buffer->size()) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } glDrawRangeElements(gl_mode, min_index, max_index, count, index_type, OffsetToPtr(offset)); CHECK_GL_ERROR(); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } } // namespace command_buffer diff --git a/o3d/command_buffer/service/cross/gl/sampler_gl.cc b/o3d/command_buffer/service/cross/gl/sampler_gl.cc index cbd1d1b..6bcc9488 100644 --- a/o3d/command_buffer/service/cross/gl/sampler_gl.cc +++ b/o3d/command_buffer/service/cross/gl/sampler_gl.cc @@ -178,7 +178,7 @@ BufferSyncInterface::ParseError GAPIGL::CreateSampler( // Dirty effect, because this sampler id may be used. DirtyEffect(); samplers_.Assign(id, new SamplerGL()); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } // Destroys the Sampler resource. @@ -186,8 +186,8 @@ BufferSyncInterface::ParseError GAPIGL::DestroySampler(ResourceID id) { // Dirty effect, because this sampler id may be used. DirtyEffect(); return samplers_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPIGL::SetSamplerStates( @@ -201,12 +201,12 @@ BufferSyncInterface::ParseError GAPIGL::SetSamplerStates( unsigned int max_anisotropy) { SamplerGL *sampler = samplers_.Get(id); if (!sampler) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; // Dirty effect, because this sampler id may be used. DirtyEffect(); sampler->SetStates(addressing_u, addressing_v, addressing_w, mag_filter, min_filter, mip_filter, max_anisotropy); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPIGL::SetSamplerBorderColor( @@ -214,11 +214,11 @@ BufferSyncInterface::ParseError GAPIGL::SetSamplerBorderColor( const RGBA &color) { SamplerGL *sampler = samplers_.Get(id); if (!sampler) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; // Dirty effect, because this sampler id may be used. DirtyEffect(); sampler->SetBorderColor(color); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPIGL::SetSamplerTexture( @@ -226,11 +226,11 @@ BufferSyncInterface::ParseError GAPIGL::SetSamplerTexture( ResourceID texture_id) { SamplerGL *sampler = samplers_.Get(id); if (!sampler) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; // Dirty effect, because this sampler id may be used. DirtyEffect(); sampler->SetTexture(texture_id); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } diff --git a/o3d/command_buffer/service/cross/gl/texture_gl.cc b/o3d/command_buffer/service/cross/gl/texture_gl.cc index 8280b77..6dcdd09 100644 --- a/o3d/command_buffer/service/cross/gl/texture_gl.cc +++ b/o3d/command_buffer/service/cross/gl/texture_gl.cc @@ -631,8 +631,8 @@ BufferSyncInterface::ParseError GAPIGL::DestroyTexture(ResourceID id) { // Dirty effect, because this texture id may be used. DirtyEffect(); return textures_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } // Creates a 2D texture resource. @@ -646,11 +646,11 @@ BufferSyncInterface::ParseError GAPIGL::CreateTexture2D( bool enable_render_surfaces) { Texture2DGL *texture = Texture2DGL::Create( width, height, levels, format, flags, enable_render_surfaces); - if (!texture) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!texture) return BufferSyncInterface::kParseInvalidArguments; // Dirty effect, because this texture id may be used. DirtyEffect(); textures_.Assign(id, texture); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } // Creates a 3D texture resource. @@ -665,11 +665,11 @@ BufferSyncInterface::ParseError GAPIGL::CreateTexture3D( bool enable_render_surfaces) { Texture3DGL *texture = Texture3DGL::Create( width, height, depth, levels, format, flags, enable_render_surfaces); - if (!texture) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!texture) return BufferSyncInterface::kParseInvalidArguments; // Dirty effect, because this texture id may be used. DirtyEffect(); textures_.Assign(id, texture); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } // Creates a cube map texture resource. @@ -682,11 +682,11 @@ BufferSyncInterface::ParseError GAPIGL::CreateTextureCube( bool enable_render_surfaces) { TextureCubeGL *texture = TextureCubeGL::Create( side, levels, format, flags, enable_render_surfaces); - if (!texture) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!texture) return BufferSyncInterface::kParseInvalidArguments; // Dirty effect, because this texture id may be used. DirtyEffect(); textures_.Assign(id, texture); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } // Copies the data into a texture resource. @@ -706,15 +706,15 @@ BufferSyncInterface::ParseError GAPIGL::SetTextureData( const void *data) { TextureGL *texture = textures_.Get(id); if (!texture) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; Volume volume = {x, y, z, width, height, depth}; // Dirty effect: SetData may need to call glBindTexture which will mess up the // sampler parameters. DirtyEffect(); return texture->SetData(volume, level, face, row_pitch, slice_pitch, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } // Copies the data from a texture resource. @@ -734,15 +734,15 @@ BufferSyncInterface::ParseError GAPIGL::GetTextureData( void *data) { TextureGL *texture = textures_.Get(id); if (!texture) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; Volume volume = {x, y, z, width, height, depth}; // Dirty effect: GetData may need to call glBindTexture which will mess up the // sampler parameters. DirtyEffect(); return texture->GetData(volume, level, face, row_pitch, slice_pitch, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } } // namespace command_buffer diff --git a/o3d/command_buffer/service/cross/mocks.h b/o3d/command_buffer/service/cross/mocks.h index 353ff0c..dbd4c62 100644 --- a/o3d/command_buffer/service/cross/mocks.h +++ b/o3d/command_buffer/service/cross/mocks.h @@ -52,7 +52,7 @@ class AsyncAPIMock : public AsyncAPIInterface { public: AsyncAPIMock() { testing::DefaultValue<BufferSyncInterface::ParseError>::Set( - BufferSyncInterface::PARSE_NO_ERROR); + BufferSyncInterface::kParseNoError); } // Predicate that matches args passed to DoCommand, by looking at the values. @@ -60,11 +60,12 @@ class AsyncAPIMock : public AsyncAPIInterface { public: IsArgs(unsigned int arg_count, const void* args) : arg_count_(arg_count), - args_(static_cast<CommandBufferEntry*>(const_cast<void*>(args))) { } + args_(static_cast<CommandBufferEntry*>(const_cast<void*>(args))) { + } bool operator() (const void* _args) const { const CommandBufferEntry* args = - static_cast<const CommandBufferEntry*>(_args); + static_cast<const CommandBufferEntry*>(_args) + 1; for (unsigned int i = 0; i < arg_count_; ++i) { if (args[i].value_uint32 != args_[i].value_uint32) return false; } @@ -79,9 +80,9 @@ class AsyncAPIMock : public AsyncAPIInterface { MOCK_METHOD3(DoCommand, BufferSyncInterface::ParseError( unsigned int command, unsigned int arg_count, - const void* args)); + const void* cmd_data)); - // Sets the engine, to forward SET_TOKEN commands to it. + // Sets the engine, to forward SetToken commands to it. void set_engine(CommandBufferEngine *engine) { engine_ = engine; } // Forwards the SetToken commands to the engine. diff --git a/o3d/command_buffer/service/win/d3d9/effect_d3d9.cc b/o3d/command_buffer/service/win/d3d9/effect_d3d9.cc index 76da265..49672bf 100644 --- a/o3d/command_buffer/service/win/d3d9/effect_d3d9.cc +++ b/o3d/command_buffer/service/win/d3d9/effect_d3d9.cc @@ -534,14 +534,14 @@ BufferSyncInterface::ParseError GAPID3D9::CreateEffect( &vertex_program_entry, &fragment_program_entry, &effect_code)) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } EffectD3D9 * effect = EffectD3D9::Create(this, effect_code, vertex_program_entry, fragment_program_entry); - if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!effect) return BufferSyncInterface::kParseInvalidArguments; effects_.Assign(id, effect); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } // Destroys the Effect resource. @@ -549,15 +549,15 @@ BufferSyncInterface::ParseError GAPID3D9::CreateEffect( BufferSyncInterface::ParseError GAPID3D9::DestroyEffect(ResourceID id) { if (id == current_effect_id_) DirtyEffect(); return effects_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } // Sets the current effect ID, dirtying the current effect. BufferSyncInterface::ParseError GAPID3D9::SetEffect(ResourceID id) { DirtyEffect(); current_effect_id_ = id; - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } // Gets the param count from the effect and store it in the memory buffer. @@ -567,9 +567,9 @@ BufferSyncInterface::ParseError GAPID3D9::GetParamCount( void *data) { EffectD3D9 *effect = effects_.Get(id); if (!effect || size < sizeof(Uint32)) // NOLINT - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; *static_cast<Uint32 *>(data) = effect->GetParamCount(); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPID3D9::CreateParam( @@ -577,11 +577,11 @@ BufferSyncInterface::ParseError GAPID3D9::CreateParam( ResourceID effect_id, unsigned int index) { EffectD3D9 *effect = effects_.Get(effect_id); - if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!effect) return BufferSyncInterface::kParseInvalidArguments; EffectParamD3D9 *param = effect->CreateParam(index); - if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!param) return BufferSyncInterface::kParseInvalidArguments; effect_params_.Assign(param_id, param); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPID3D9::CreateParamByName( @@ -590,18 +590,18 @@ BufferSyncInterface::ParseError GAPID3D9::CreateParamByName( unsigned int size, const void *name) { EffectD3D9 *effect = effects_.Get(effect_id); - if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!effect) return BufferSyncInterface::kParseInvalidArguments; std::string string_name(static_cast<const char *>(name), size); EffectParamD3D9 *param = effect->CreateParamByName(string_name.c_str()); - if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!param) return BufferSyncInterface::kParseInvalidArguments; effect_params_.Assign(param_id, param); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPID3D9::DestroyParam(ResourceID id) { return effect_params_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPID3D9::SetParamData( @@ -609,10 +609,10 @@ BufferSyncInterface::ParseError GAPID3D9::SetParamData( unsigned int size, const void *data) { EffectParamD3D9 *param = effect_params_.Get(id); - if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!param) return BufferSyncInterface::kParseInvalidArguments; return param->SetData(this, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPID3D9::GetParamDesc( @@ -620,10 +620,10 @@ BufferSyncInterface::ParseError GAPID3D9::GetParamDesc( unsigned int size, void *data) { EffectParamD3D9 *param = effect_params_.Get(id); - if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!param) return BufferSyncInterface::kParseInvalidArguments; return param->GetDesc(size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } // Gets the stream count from the effect and stores it in the memory buffer. @@ -633,9 +633,9 @@ BufferSyncInterface::ParseError GAPID3D9::GetStreamCount( void *data) { EffectD3D9 *effect = effects_.Get(id); if (!effect || size < sizeof(Uint32)) // NOLINT - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; *static_cast<Uint32 *>(data) = effect->GetStreamCount(); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPID3D9::GetStreamDesc( @@ -644,10 +644,10 @@ BufferSyncInterface::ParseError GAPID3D9::GetStreamDesc( unsigned int size, void *data) { EffectD3D9 *effect = effects_.Get(id); - if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!effect) return BufferSyncInterface::kParseInvalidArguments; return effect->GetStreamDesc(index, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } diff --git a/o3d/command_buffer/service/win/d3d9/gapi_d3d9.cc b/o3d/command_buffer/service/win/d3d9/gapi_d3d9.cc index 824f504..5c71793 100644 --- a/o3d/command_buffer/service/win/d3d9/gapi_d3d9.cc +++ b/o3d/command_buffer/service/win/d3d9/gapi_d3d9.cc @@ -217,7 +217,7 @@ static unsigned int RGBAToARGB(unsigned int rgba) { BufferSyncInterface::ParseError GAPID3D9::SetVertexStruct(ResourceID id) { current_vertex_struct_ = id; validate_streams_ = true; - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } // Sets in D3D the input streams of the current vertex struct. @@ -261,22 +261,22 @@ BufferSyncInterface::ParseError GAPID3D9::Draw( unsigned int count) { if (validate_streams_ && !ValidateStreams()) { // TODO: add proper error management - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } if (validate_effect_ && !ValidateEffect()) { // TODO: add proper error management - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } DCHECK(current_effect_); if (!current_effect_->CommitParameters(this)) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } if (first + count > max_vertices_) { // TODO: add proper error management - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } HR(d3d_device_->DrawPrimitive(D3DPrimitive(primitive_type), first, count)); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } // Draws with the current vertex struct. @@ -288,29 +288,29 @@ BufferSyncInterface::ParseError GAPID3D9::DrawIndexed( unsigned int min_index, unsigned int max_index) { IndexBufferD3D9 *index_buffer = index_buffers_.Get(index_buffer_id); - if (!index_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments; if (validate_streams_ && !ValidateStreams()) { // TODO: add proper error management - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } if (validate_effect_ && !ValidateEffect()) { // TODO: add proper error management - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } DCHECK(current_effect_); if (!current_effect_->CommitParameters(this)) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } if ((min_index >= max_vertices_) || (max_index > max_vertices_)) { // TODO: add proper error management - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } HR(d3d_device_->SetIndices(index_buffer->d3d_index_buffer())); HR(d3d_device_->DrawIndexedPrimitive(D3DPrimitive(primitive_type), 0, min_index, max_index - min_index + 1, first, count)); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } } // namespace command_buffer diff --git a/o3d/command_buffer/service/win/d3d9/geometry_d3d9.cc b/o3d/command_buffer/service/win/d3d9/geometry_d3d9.cc index e5f32b9..deeab89 100644 --- a/o3d/command_buffer/service/win/d3d9/geometry_d3d9.cc +++ b/o3d/command_buffer/service/win/d3d9/geometry_d3d9.cc @@ -316,14 +316,14 @@ BufferSyncInterface::ParseError GAPID3D9::CreateVertexBuffer( VertexBufferD3D9 *vertex_buffer = new VertexBufferD3D9(size, flags); vertex_buffer->Create(this); vertex_buffers_.Assign(id, vertex_buffer); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } // Destroys a VertexBufferD3D9 resource. BufferSyncInterface::ParseError GAPID3D9::DestroyVertexBuffer(ResourceID id) { return vertex_buffers_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } // Copies the data into the VertexBufferD3D9 resource. @@ -333,10 +333,10 @@ BufferSyncInterface::ParseError GAPID3D9::SetVertexBufferData( unsigned int size, const void *data) { VertexBufferD3D9 *vertex_buffer = vertex_buffers_.Get(id); - if (!vertex_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!vertex_buffer) return BufferSyncInterface::kParseInvalidArguments; return vertex_buffer->SetData(offset, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } // Copies the data from the VertexBufferD3D9 resource. @@ -346,10 +346,10 @@ BufferSyncInterface::ParseError GAPID3D9::GetVertexBufferData( unsigned int size, void *data) { VertexBufferD3D9 *vertex_buffer = vertex_buffers_.Get(id); - if (!vertex_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!vertex_buffer) return BufferSyncInterface::kParseInvalidArguments; return vertex_buffer->GetData(offset, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } // Creates and assigns an IndexBufferD3D9 resource. @@ -360,14 +360,14 @@ BufferSyncInterface::ParseError GAPID3D9::CreateIndexBuffer( IndexBufferD3D9 *index_buffer = new IndexBufferD3D9(size, flags); index_buffer->Create(this); index_buffers_.Assign(id, index_buffer); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } // Destroys an IndexBufferD3D9 resource. BufferSyncInterface::ParseError GAPID3D9::DestroyIndexBuffer(ResourceID id) { return index_buffers_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } // Copies the data into the IndexBufferD3D9 resource. @@ -377,10 +377,10 @@ BufferSyncInterface::ParseError GAPID3D9::SetIndexBufferData( unsigned int size, const void *data) { IndexBufferD3D9 *index_buffer = index_buffers_.Get(id); - if (!index_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments; return index_buffer->SetData(offset, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } // Copies the data from the IndexBufferD3D9 resource. @@ -390,10 +390,10 @@ BufferSyncInterface::ParseError GAPID3D9::GetIndexBufferData( unsigned int size, void *data) { IndexBufferD3D9 *index_buffer = index_buffers_.Get(id); - if (!index_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments; return index_buffer->GetData(offset, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } // Creates and assigns a VertexStructD3D9 resource. @@ -402,15 +402,15 @@ BufferSyncInterface::ParseError GAPID3D9::CreateVertexStruct( if (id == current_vertex_struct_) validate_streams_ = true; VertexStructD3D9 *vertex_struct = new VertexStructD3D9(input_count); vertex_structs_.Assign(id, vertex_struct); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } // Destroys a VertexStructD3D9 resource. BufferSyncInterface::ParseError GAPID3D9::DestroyVertexStruct(ResourceID id) { if (id == current_vertex_struct_) validate_streams_ = true; return vertex_structs_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } // Sets an input into a VertexStructD3D9 resource. @@ -426,10 +426,10 @@ BufferSyncInterface::ParseError GAPID3D9::SetVertexInput( if (vertex_buffer_id == current_vertex_struct_) validate_streams_ = true; VertexStructD3D9 *vertex_struct = vertex_structs_.Get(vertex_struct_id); if (!vertex_struct || input_index >= vertex_struct->count()) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; vertex_struct->SetInput(input_index, vertex_buffer_id, offset, stride, type, semantic, semantic_index); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } } // namespace command_buffer diff --git a/o3d/command_buffer/service/win/d3d9/render_surface_d3d9.cc b/o3d/command_buffer/service/win/d3d9/render_surface_d3d9.cc index 2883baf..a26d0dc 100644 --- a/o3d/command_buffer/service/win/d3d9/render_surface_d3d9.cc +++ b/o3d/command_buffer/service/win/d3d9/render_surface_d3d9.cc @@ -136,11 +136,11 @@ BufferSyncInterface::ParseError GAPID3D9::CreateRenderSurface( ResourceID texture_id) { if (id == current_surface_id_) { // This will delete the current surface which would be bad. - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } TextureD3D9 *texture = textures_.Get(texture_id); if (!texture->render_surfaces_enabled()) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } else { RenderSurfaceD3D9 *render_surface = RenderSurfaceD3D9::Create(this, width, @@ -149,20 +149,20 @@ BufferSyncInterface::ParseError GAPID3D9::CreateRenderSurface( side, texture); if (render_surface == NULL) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } render_surfaces_.Assign(id, render_surface); } - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPID3D9::DestroyRenderSurface(ResourceID id) { if (id == current_surface_id_) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } return render_surfaces_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPID3D9::CreateDepthSurface( @@ -171,24 +171,24 @@ BufferSyncInterface::ParseError GAPID3D9::CreateDepthSurface( unsigned int height) { if (id == current_depth_surface_id_) { // This will delete the current surface which would be bad. - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } RenderDepthStencilSurfaceD3D9 *depth_surface = RenderDepthStencilSurfaceD3D9::Create(this, width, height); if (depth_surface == NULL) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } depth_surfaces_.Assign(id, depth_surface); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPID3D9::DestroyDepthSurface(ResourceID id) { if (id == current_depth_surface_id_) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } return depth_surfaces_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPID3D9::SetRenderSurface( @@ -200,7 +200,7 @@ BufferSyncInterface::ParseError GAPID3D9::SetRenderSurface( depth_surfaces_.Get(depth_stencil_id); if (d3d_render_surface == NULL && d3d_render_depth_surface == NULL) { - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; } IDirect3DSurface9 *d3d_surface = @@ -215,7 +215,7 @@ BufferSyncInterface::ParseError GAPID3D9::SetRenderSurface( HR(device->SetDepthStencilSurface(d3d_depth_surface)); current_surface_id_ = render_surface_id; current_depth_surface_id_ = depth_stencil_id; - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } void GAPID3D9::SetBackSurfaces() { diff --git a/o3d/command_buffer/service/win/d3d9/sampler_d3d9.cc b/o3d/command_buffer/service/win/d3d9/sampler_d3d9.cc index 3645a5d..e37c37f 100644 --- a/o3d/command_buffer/service/win/d3d9/sampler_d3d9.cc +++ b/o3d/command_buffer/service/win/d3d9/sampler_d3d9.cc @@ -139,7 +139,7 @@ BufferSyncInterface::ParseError GAPID3D9::CreateSampler( // Dirty effect, because this sampler id may be used DirtyEffect(); samplers_.Assign(id, new SamplerD3D9()); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } // Destroys the Sampler resource. @@ -147,8 +147,8 @@ BufferSyncInterface::ParseError GAPID3D9::DestroySampler(ResourceID id) { // Dirty effect, because this sampler id may be used DirtyEffect(); return samplers_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } BufferSyncInterface::ParseError GAPID3D9::SetSamplerStates( @@ -162,12 +162,12 @@ BufferSyncInterface::ParseError GAPID3D9::SetSamplerStates( unsigned int max_anisotropy) { SamplerD3D9 *sampler = samplers_.Get(id); if (!sampler) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; // Dirty effect, because this sampler id may be used DirtyEffect(); sampler->SetStates(addressing_u, addressing_v, addressing_w, mag_filter, min_filter, mip_filter, max_anisotropy); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPID3D9::SetSamplerBorderColor( @@ -175,11 +175,11 @@ BufferSyncInterface::ParseError GAPID3D9::SetSamplerBorderColor( const RGBA &color) { SamplerD3D9 *sampler = samplers_.Get(id); if (!sampler) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; // Dirty effect, because this sampler id may be used DirtyEffect(); sampler->SetBorderColor(color); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } BufferSyncInterface::ParseError GAPID3D9::SetSamplerTexture( @@ -187,11 +187,11 @@ BufferSyncInterface::ParseError GAPID3D9::SetSamplerTexture( ResourceID texture_id) { SamplerD3D9 *sampler = samplers_.Get(id); if (!sampler) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; // Dirty effect, because this sampler id may be used DirtyEffect(); sampler->SetTexture(texture_id); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } diff --git a/o3d/command_buffer/service/win/d3d9/texture_d3d9.cc b/o3d/command_buffer/service/win/d3d9/texture_d3d9.cc index b11121fa..cb220f8 100644 --- a/o3d/command_buffer/service/win/d3d9/texture_d3d9.cc +++ b/o3d/command_buffer/service/win/d3d9/texture_d3d9.cc @@ -612,8 +612,8 @@ BufferSyncInterface::ParseError GAPID3D9::DestroyTexture(ResourceID id) { // Dirty effect, because this texture id may be used DirtyEffect(); return textures_.Destroy(id) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } // Creates a 2D texture resource. @@ -628,11 +628,11 @@ BufferSyncInterface::ParseError GAPID3D9::CreateTexture2D( Texture2DD3D9 *texture = Texture2DD3D9::Create(this, width, height, levels, format, flags, enable_render_surfaces); - if (!texture) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!texture) return BufferSyncInterface::kParseInvalidArguments; // Dirty effect, because this texture id may be used DirtyEffect(); textures_.Assign(id, texture); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } // Creates a 3D texture resource. @@ -648,11 +648,11 @@ BufferSyncInterface::ParseError GAPID3D9::CreateTexture3D( Texture3DD3D9 *texture = Texture3DD3D9::Create(this, width, height, depth, levels, format, flags, enable_render_surfaces); - if (!texture) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!texture) return BufferSyncInterface::kParseInvalidArguments; // Dirty effect, because this texture id may be used DirtyEffect(); textures_.Assign(id, texture); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } // Creates a cube map texture resource. @@ -666,11 +666,11 @@ BufferSyncInterface::ParseError GAPID3D9::CreateTextureCube( TextureCubeD3D9 *texture = TextureCubeD3D9::Create(this, side, levels, format, flags, enable_render_surfaces); - if (!texture) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + if (!texture) return BufferSyncInterface::kParseInvalidArguments; // Dirty effect, because this texture id may be used DirtyEffect(); textures_.Assign(id, texture); - return BufferSyncInterface::PARSE_NO_ERROR; + return BufferSyncInterface::kParseNoError; } // Copies the data into a texture resource. @@ -690,12 +690,12 @@ BufferSyncInterface::ParseError GAPID3D9::SetTextureData( const void *data) { TextureD3D9 *texture = textures_.Get(id); if (!texture) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; Volume volume = {x, y, z, width, height, depth}; return texture->SetData(this, volume, level, face, row_pitch, slice_pitch, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } // Copies the data from a texture resource. @@ -715,12 +715,12 @@ BufferSyncInterface::ParseError GAPID3D9::GetTextureData( void *data) { TextureD3D9 *texture = textures_.Get(id); if (!texture) - return BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + return BufferSyncInterface::kParseInvalidArguments; Volume volume = {x, y, z, width, height, depth}; return texture->GetData(this, volume, level, face, row_pitch, slice_pitch, size, data) ? - BufferSyncInterface::PARSE_NO_ERROR : - BufferSyncInterface::PARSE_INVALID_ARGUMENTS; + BufferSyncInterface::kParseNoError : + BufferSyncInterface::kParseInvalidArguments; } } // namespace command_buffer diff --git a/o3d/core/cross/command_buffer/buffer_cb.cc b/o3d/core/cross/command_buffer/buffer_cb.cc index 0914abd..32adbc9 100644 --- a/o3d/core/cross/command_buffer/buffer_cb.cc +++ b/o3d/core/cross/command_buffer/buffer_cb.cc @@ -56,29 +56,23 @@ VertexBufferCB::~VertexBufferCB() { ConcreteFree(); } -// Sends the DESTROY_VERTEX_BUFFER command, and frees the ID from the allocator. +// Sends the DestroyVertexBuffer command, and frees the ID from the allocator. void VertexBufferCB::ConcreteFree() { if (resource_id_ != command_buffer::kInvalidResource) { CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[1]; - args[0].value_uint32 = resource_id_; - helper->AddCommand(command_buffer::DESTROY_VERTEX_BUFFER, 1, args); + helper->DestroyVertexBuffer(resource_id_); renderer_->vertex_buffer_ids().FreeID(resource_id_); resource_id_ = command_buffer::kInvalidResource; } } -// Allocates a resource ID, and sends the CREATE_VERTEX_BUFFER command. +// Allocates a resource ID, and sends the CreateVertexBuffer command. bool VertexBufferCB::ConcreteAllocate(size_t size_in_bytes) { ConcreteFree(); if (size_in_bytes > 0) { resource_id_ = renderer_->vertex_buffer_ids().AllocateID(); CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[3]; - args[0].value_uint32 = resource_id_; - args[1].value_uint32 = size_in_bytes; - args[2].value_uint32 = 0; // no flags. - helper->AddCommand(command_buffer::CREATE_VERTEX_BUFFER, 3, args); + helper->CreateVertexBuffer(resource_id_, size_in_bytes, 0); has_data_ = false; } return true; @@ -86,7 +80,7 @@ bool VertexBufferCB::ConcreteAllocate(size_t size_in_bytes) { // Allocates the locked region into the transfer shared memory area. If the // buffer resource contains data, copies it back (by sending the -// GET_VERTEX_BUFFER_DATA command). +// GetVertexBufferData command). bool VertexBufferCB::ConcreteLock(AccessMode access_mode, void **buffer_data) { *buffer_data = NULL; if (GetSizeInBytes() == 0 || lock_pointer_) @@ -95,32 +89,27 @@ bool VertexBufferCB::ConcreteLock(AccessMode access_mode, void **buffer_data) { if (!lock_pointer_) return false; if (has_data_) { CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[5]; - args[0].value_uint32 = resource_id_; - args[1].value_uint32 = 0; - args[2].value_uint32 = GetSizeInBytes(); - args[3].value_uint32 = renderer_->transfer_shm_id(); - args[4].value_uint32 = renderer_->allocator()->GetOffset(lock_pointer_); - helper->AddCommand(command_buffer::GET_VERTEX_BUFFER_DATA, 5, args); + helper->GetVertexBufferData( + resource_id_, 0, GetSizeInBytes(), + renderer_->transfer_shm_id(), + renderer_->allocator()->GetOffset(lock_pointer_)); helper->Finish(); } *buffer_data = lock_pointer_; return true; } -// Copies the data into the resource by sending the SET_VERTEX_BUFFER_DATA +// Copies the data into the resource by sending the SetVertexBufferData // command, then frees the shared memory, pending the transfer completion. bool VertexBufferCB::ConcreteUnlock() { if (GetSizeInBytes() == 0 || !lock_pointer_) return false; CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[5]; - args[0].value_uint32 = resource_id_; - args[1].value_uint32 = 0; - args[2].value_uint32 = GetSizeInBytes(); - args[3].value_uint32 = renderer_->transfer_shm_id(); - args[4].value_uint32 = renderer_->allocator()->GetOffset(lock_pointer_); - helper->AddCommand(command_buffer::SET_VERTEX_BUFFER_DATA, 5, args); + helper->SetVertexBufferData( + resource_id_, 0, GetSizeInBytes(), + renderer_->transfer_shm_id(), + renderer_->allocator()->GetOffset(lock_pointer_)); + renderer_->allocator()->FreePendingToken(lock_pointer_, helper->InsertToken()); lock_pointer_ = NULL; @@ -142,29 +131,25 @@ IndexBufferCB::~IndexBufferCB() { ConcreteFree(); } -// Sends the DESTROY_INDEX_BUFFER command, and frees the ID from the allocator. +// Sends the DestroyIndexBuffer command, and frees the ID from the allocator. void IndexBufferCB::ConcreteFree() { if (resource_id_ != command_buffer::kInvalidResource) { CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[1]; - args[0].value_uint32 = resource_id_; - helper->AddCommand(command_buffer::DESTROY_INDEX_BUFFER, 1, args); + helper->DestroyIndexBuffer(resource_id_); renderer_->index_buffer_ids().FreeID(resource_id_); resource_id_ = command_buffer::kInvalidResource; } } -// Allocates a resource ID, and sends the CREATE_INDEX_BUFFER command. +// Allocates a resource ID, and sends the CreateIndexBuffer command. bool IndexBufferCB::ConcreteAllocate(size_t size_in_bytes) { ConcreteFree(); if (size_in_bytes > 0) { resource_id_ = renderer_->index_buffer_ids().AllocateID(); CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[3]; - args[0].value_uint32 = resource_id_; - args[1].value_uint32 = size_in_bytes; - args[2].value_uint32 = command_buffer::index_buffer::INDEX_32BIT; - helper->AddCommand(command_buffer::CREATE_INDEX_BUFFER, 3, args); + helper->CreateIndexBuffer( + resource_id_, size_in_bytes, + command_buffer::index_buffer::INDEX_32BIT); has_data_ = false; } return true; @@ -172,7 +157,7 @@ bool IndexBufferCB::ConcreteAllocate(size_t size_in_bytes) { // Allocates the locked region into the transfer shared memory area. If the // buffer resource contains data, copies it back (by sending the -// GET_INDEX_BUFFER_DATA command). +// GetIndexBufferData command). bool IndexBufferCB::ConcreteLock(AccessMode access_mode, void **buffer_data) { *buffer_data = NULL; if (GetSizeInBytes() == 0 || lock_pointer_) @@ -181,32 +166,26 @@ bool IndexBufferCB::ConcreteLock(AccessMode access_mode, void **buffer_data) { if (!lock_pointer_) return false; if (has_data_) { CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[5]; - args[0].value_uint32 = resource_id_; - args[1].value_uint32 = 0; - args[2].value_uint32 = GetSizeInBytes(); - args[3].value_uint32 = renderer_->transfer_shm_id(); - args[4].value_uint32 = renderer_->allocator()->GetOffset(lock_pointer_); - helper->AddCommand(command_buffer::GET_INDEX_BUFFER_DATA, 5, args); + helper->GetIndexBufferData( + resource_id_, 0, GetSizeInBytes(), + renderer_->transfer_shm_id(), + renderer_->allocator()->GetOffset(lock_pointer_)); helper->Finish(); } *buffer_data = lock_pointer_; return true; } -// Copies the data into the resource by sending the SET_INDEX_BUFFER_DATA +// Copies the data into the resource by sending the SetIndexBufferData // command, then frees the shared memory, pending the transfer completion. bool IndexBufferCB::ConcreteUnlock() { if (GetSizeInBytes() == 0 || !lock_pointer_) return false; CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[5]; - args[0].value_uint32 = resource_id_; - args[1].value_uint32 = 0; - args[2].value_uint32 = GetSizeInBytes(); - args[3].value_uint32 = renderer_->transfer_shm_id(); - args[4].value_uint32 = renderer_->allocator()->GetOffset(lock_pointer_); - helper->AddCommand(command_buffer::SET_INDEX_BUFFER_DATA, 5, args); + helper->SetIndexBufferData( + resource_id_, 0, GetSizeInBytes(), + renderer_->transfer_shm_id(), + renderer_->allocator()->GetOffset(lock_pointer_)); renderer_->allocator()->FreePendingToken(lock_pointer_, helper->InsertToken()); lock_pointer_ = NULL; diff --git a/o3d/core/cross/command_buffer/effect_cb.cc b/o3d/core/cross/command_buffer/effect_cb.cc index ed35a77..332da8f 100644 --- a/o3d/core/cross/command_buffer/effect_cb.cc +++ b/o3d/core/cross/command_buffer/effect_cb.cc @@ -92,19 +92,17 @@ bool EffectCB::LoadFromFXString(const String& source) { ResourceID resource_id = renderer_->effect_ids().AllocateID(); CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[4]; - args[0].value_uint32 = resource_id; - args[1].value_uint32 = source_size; - args[2].value_uint32 = renderer_->transfer_shm_id(); - args[3].value_uint32 = renderer_->allocator()->GetOffset(buffer_data); - helper->AddCommand(command_buffer::CREATE_EFFECT, 4, args); + helper->CreateEffect( + resource_id, source_size, + renderer_->transfer_shm_id(), + renderer_->allocator()->GetOffset(buffer_data)); renderer_->allocator()->FreePendingToken(buffer_data, helper->InsertToken()); // NOTE: we're calling Finish to check the command result, to see if // the effect has succesfully compiled. helper->Finish(); if (renderer_->sync_interface()->GetParseError() != - BufferSyncInterface::PARSE_NO_ERROR) { + BufferSyncInterface::kParseNoError) { O3D_ERROR(service_locator()) << "Effect failed to compile."; renderer_->effect_ids().FreeID(resource_id); return false; @@ -140,9 +138,7 @@ void EffectCB::Destroy() { ++generation_; if (resource_id_ != command_buffer::kInvalidResource) { CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[1]; - args[0].value_uint32 = resource_id_; - helper->AddCommand(command_buffer::DESTROY_EFFECT, 1, args); + helper->DestroyEffect(resource_id_); renderer_->effect_ids().FreeID(resource_id_); resource_id_ = command_buffer::kInvalidResource; } diff --git a/o3d/core/cross/command_buffer/param_cache_cb.cc b/o3d/core/cross/command_buffer/param_cache_cb.cc index c41d72e..e6351dc 100644 --- a/o3d/core/cross/command_buffer/param_cache_cb.cc +++ b/o3d/core/cross/command_buffer/param_cache_cb.cc @@ -70,15 +70,8 @@ class TypedParamHandlerCB : public ParamHandlerCB { // This template definition only works for value types (floatn, matrix, int, // ..., but not textures or samplers). virtual void SetValue(CommandBufferHelper *helper) { - static const unsigned int kEntryCount = - (sizeof(typename T::DataType) + 3) / 4; - CommandBufferEntry args[2 + kEntryCount]; typename T::DataType value = param_->value(); - args[0].value_uint32 = id_; - args[1].value_uint32 = sizeof(value); - memcpy(args + 2, &value, sizeof(value)); - helper->AddCommand(command_buffer::SET_PARAM_DATA_IMMEDIATE, - 2 + kEntryCount, args); + helper->SetParamDataImmediate(id_, sizeof(value), &value); } private: T* param_; @@ -99,12 +92,8 @@ class MatrixParamHandlerColumnsCB : public ParamHandlerCB { // Sends the param value to the service. virtual void SetValue(CommandBufferHelper *helper) { - CommandBufferEntry args[18]; Matrix4 value = transpose(param_->value()); - args[0].value_uint32 = id_; - args[1].value_uint32 = sizeof(value); - memcpy(args + 2, &value, sizeof(value)); - helper->AddCommand(command_buffer::SET_PARAM_DATA_IMMEDIATE, 18, args); + helper->SetParamDataImmediate(id_, sizeof(value), &value); } private: ParamMatrix4* param_; @@ -121,17 +110,15 @@ class SamplerParamHandlerCB : public ParamHandlerCB { // Sends the param value to the service. virtual void SetValue(CommandBufferHelper *helper) { SamplerCB *sampler = down_cast<SamplerCB *>(param_->value()); - CommandBufferEntry args[3]; - args[0].value_uint32 = id_; - args[1].value_uint32 = sizeof(ResourceID); + uint32 value; if (!sampler) { // TODO: use error sampler - args[2].value_uint32 = command_buffer::kInvalidResource; + value = command_buffer::kInvalidResource; } else { sampler->SetTextureAndStates(); - args[2].value_uint32 = sampler->resource_id(); + value = sampler->resource_id(); } - helper->AddCommand(command_buffer::SET_PARAM_DATA_IMMEDIATE, 3, args); + helper->SetParamDataImmediate(id_, sizeof(value), &value); } private: ParamSampler* param_; diff --git a/o3d/core/cross/command_buffer/primitive_cb.cc b/o3d/core/cross/command_buffer/primitive_cb.cc index 2f02dba..208a1b0 100644 --- a/o3d/core/cross/command_buffer/primitive_cb.cc +++ b/o3d/core/cross/command_buffer/primitive_cb.cc @@ -112,8 +112,7 @@ void PrimitiveCB::PlatformSpecificRender(Renderer* renderer, IndexBufferCB *index_buffer_cb = down_cast<IndexBufferCB *>(index_buffer()); if (!index_buffer_cb) { - // TODO: draw non-index in this case ? we don't do it currently on - // other platforms, so keep compatibility. + // TODO(gman): draw non-indexed primitives. DLOG(INFO) << "Trying to draw with an empty index buffer."; return; } @@ -130,23 +129,15 @@ void PrimitiveCB::PlatformSpecificRender(Renderer* renderer, stream_bank_cb->BindStreamsForRendering(); CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[6]; // Sets current effect. // TODO: cache current effect ? - args[0].value_uint32 = effect_cb->resource_id(); - helper->AddCommand(command_buffer::SET_EFFECT, 1, args); + helper->SetEffect(effect_cb->resource_id()); param_cache_cb->RunHandlers(helper); - // Draws. - args[0].value_uint32 = cb_primitive_type; - args[1].value_uint32 = index_buffer_cb->resource_id(); - args[2].value_uint32 = 0; // first index. - args[3].value_uint32 = number_primitives_; // primitive count. - args[4].value_uint32 = 0; // min index. - args[5].value_uint32 = number_vertices_ - 1; // max index. - helper->AddCommand(command_buffer::DRAW_INDEXED, 6, args); + helper->DrawIndexed(cb_primitive_type, index_buffer_cb->resource_id(), + 0, number_primitives_, 0, number_vertices_ - 1); } } // namespace o3d diff --git a/o3d/core/cross/command_buffer/render_surface_cb.cc b/o3d/core/cross/command_buffer/render_surface_cb.cc index bb967d2..443cc2f 100644 --- a/o3d/core/cross/command_buffer/render_surface_cb.cc +++ b/o3d/core/cross/command_buffer/render_surface_cb.cc @@ -59,17 +59,10 @@ RenderSurfaceCB::RenderSurfaceCB(ServiceLocator *service_locator, ResourceID id = renderer_->render_surface_ids().AllocateID(); resource_id_ = id; CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[4]; - args[0].value_uint32 = id; - args[1].value_uint32 = - create_render_surface_cmd::Width::MakeValue(width) | - create_render_surface_cmd::Height::MakeValue(height); - args[2].value_uint32 = - create_render_surface_cmd::Levels::MakeValue(mip_level) | - create_render_surface_cmd::Side::MakeValue(side); - args[3].value_uint32 = - reinterpret_cast<ResourceID>(texture->GetTextureHandle()); - helper->AddCommand(command_buffer::CREATE_RENDER_SURFACE, 4, args); + helper->CreateRenderSurface( + id, + reinterpret_cast<uint32>(texture->GetTextureHandle()), + width, height, mip_level, side); } RenderSurfaceCB::~RenderSurfaceCB() { @@ -80,9 +73,7 @@ void RenderSurfaceCB::Destroy() { // This should never be called during rendering. if (resource_id_ != command_buffer::kInvalidResource) { CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[1]; - args[0].value_uint32 = resource_id_; - helper->AddCommand(command_buffer::DESTROY_RENDER_SURFACE, 1, args); + helper->DestroyRenderSurface(resource_id_); renderer_->render_surface_ids().FreeID(resource_id_); resource_id_ = command_buffer::kInvalidResource; } @@ -102,20 +93,13 @@ RenderDepthStencilSurfaceCB::RenderDepthStencilSurfaceCB( ResourceID id = renderer_->depth_surface_ids().AllocateID(); resource_id_ = id; CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[2]; - args[0].value_uint32 = id; - args[1].value_uint32 = - create_render_surface_cmd::Width::MakeValue(width) | - create_render_surface_cmd::Height::MakeValue(height); - helper->AddCommand(command_buffer::CREATE_DEPTH_SURFACE, 2, args); + helper->CreateDepthSurface(id, width, height); } void RenderDepthStencilSurfaceCB::Destroy() { if (resource_id_ != command_buffer::kInvalidResource) { CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[1]; - args[0].value_uint32 = resource_id_; - helper->AddCommand(command_buffer::DESTROY_DEPTH_SURFACE, 1, args); + helper->DestroyDepthSurface(resource_id_); renderer_->depth_surface_ids().FreeID(resource_id_); resource_id_ = command_buffer::kInvalidResource; } diff --git a/o3d/core/cross/command_buffer/renderer_cb.cc b/o3d/core/cross/command_buffer/renderer_cb.cc index e2d3998..f2d919b5 100644 --- a/o3d/core/cross/command_buffer/renderer_cb.cc +++ b/o3d/core/cross/command_buffer/renderer_cb.cc @@ -187,38 +187,31 @@ void RendererCB::PlatformSpecificClear(const Float4 &color, uint32 buffers = (color_flag ? GAPIInterface::COLOR : 0) | (depth_flag ? GAPIInterface::DEPTH : 0) | (stencil_flag ? GAPIInterface::STENCIL : 0); - command_buffer::CommandBufferEntry args[7]; - args[0].value_uint32 = buffers; - args[1].value_float = color[0]; - args[2].value_float = color[1]; - args[3].value_float = color[2]; - args[4].value_float = color[3]; - args[5].value_float = depth; - args[6].value_uint32 = stencil; - helper_->AddCommand(command_buffer::CLEAR, 7, args); + helper_->Clear(buffers, color[0], color[1], color[2], color[3], + depth, stencil); } void RendererCB::PlatformSpecificEndDraw() { } -// Adds the BEGIN_FRAME command to the command buffer. +// Adds the BeginFrame command to the command buffer. bool RendererCB::PlatformSpecificStartRendering() { // Any device issues are handled in the command buffer backend DCHECK(helper_); - helper_->AddCommand(command_buffer::BEGIN_FRAME, 0 , NULL); + helper_->BeginFrame(); return true; } -// Adds the END_FRAME command to the command buffer, and flushes the commands. +// Adds the EndFrame command to the command buffer, and flushes the commands. void RendererCB::PlatformSpecificFinishRendering() { // Any device issues are handled in the command buffer backend - helper_->AddCommand(command_buffer::END_FRAME, 0 , NULL); + helper_->EndFrame(); helper_->WaitForToken(frame_token_); frame_token_ = helper_->InsertToken(); } void RendererCB::PlatformSpecificPresent() { - // TODO(gman): The END_FRAME command needs to be split into END_FRAME + // TODO(gman): The EndFrame command needs to be split into EndFrame // and PRESENT. } @@ -231,14 +224,13 @@ void RendererCB::SetRenderSurfacesPlatformSpecific( down_cast<const RenderSurfaceCB*>(surface); const RenderDepthStencilSurfaceCB* surface_depth_cb = down_cast<const RenderDepthStencilSurfaceCB*>(surface_depth); - command_buffer::CommandBufferEntry args[2]; - args[0].value_uint32 = surface_cb->resource_id(); - args[1].value_uint32 = surface_depth_cb->resource_id(); - helper_->AddCommand(command_buffer::SET_RENDER_SURFACE, 2, args); + helper_->SetRenderSurface( + surface_cb->resource_id(), + surface_depth_cb->resource_id()); } void RendererCB::SetBackBufferPlatformSpecific() { - helper_->AddCommand(command_buffer::SET_BACK_SURFACES, 0, NULL); + helper_->SetBackSurfaces(); } // Creates a StreamBank, returning a platform specific implementation class. @@ -314,14 +306,7 @@ void RendererCB::SetViewportInPixels(int left, int height, float min_z, float max_z) { - command_buffer::CommandBufferEntry args[6]; - args[0].value_uint32 = left; - args[1].value_uint32 = top; - args[2].value_uint32 = width; - args[3].value_uint32 = height; - args[4].value_float = min_z; - args[5].value_float = max_z; - helper_->AddCommand(command_buffer::SET_VIEWPORT, 6, args); + helper_->SetViewport(left, top, width, height, min_z, max_z); } const int* RendererCB::GetRGBAUByteNSwizzleTable() { diff --git a/o3d/core/cross/command_buffer/sampler_cb.cc b/o3d/core/cross/command_buffer/sampler_cb.cc index df7b02f..b185076 100644 --- a/o3d/core/cross/command_buffer/sampler_cb.cc +++ b/o3d/core/cross/command_buffer/sampler_cb.cc @@ -86,15 +86,11 @@ SamplerCB::SamplerCB(ServiceLocator* service_locator, RendererCB* renderer) renderer_(renderer) { DCHECK(renderer_); resource_id_ = renderer_->sampler_ids().AllocateID(); - CommandBufferEntry args[1]; - args[0].value_uint32 = resource_id_; - renderer_->helper()->AddCommand(command_buffer::CREATE_SAMPLER, 1, args); + renderer_->helper()->CreateSampler(resource_id_); } SamplerCB::~SamplerCB() { - CommandBufferEntry args[1]; - args[0].value_uint32 = resource_id_; - renderer_->helper()->AddCommand(command_buffer::DESTROY_SAMPLER, 1, args); + renderer_->helper()->DestroySampler(resource_id_); renderer_->sampler_ids().FreeID(resource_id_); } @@ -102,6 +98,7 @@ void SamplerCB::SetTextureAndStates() { CommandBufferHelper *helper = renderer_->helper(); sampler::AddressingMode address_mode_u_cb = AddressModeToCB(address_mode_u()); sampler::AddressingMode address_mode_v_cb = AddressModeToCB(address_mode_v()); + sampler::AddressingMode address_mode_w_cb = AddressModeToCB(address_mode_w()); sampler::FilteringMode mag_filter_cb = FilterTypeToCB(mag_filter()); sampler::FilteringMode min_filter_cb = FilterTypeToCB(min_filter()); sampler::FilteringMode mip_filter_cb = FilterTypeToCB(mip_filter()); @@ -113,24 +110,19 @@ void SamplerCB::SetTextureAndStates() { if (min_filter() != Sampler::ANISOTROPIC) { max_anisotropy_cb = 1; } - CommandBufferEntry args[5]; - args[0].value_uint32 = resource_id_; - args[1].value_uint32 = - set_sampler_states::AddressingU::MakeValue(address_mode_u_cb) | - set_sampler_states::AddressingV::MakeValue(address_mode_v_cb) | - set_sampler_states::AddressingW::MakeValue(sampler::WRAP) | - set_sampler_states::MagFilter::MakeValue(mag_filter_cb) | - set_sampler_states::MinFilter::MakeValue(min_filter_cb) | - set_sampler_states::MipFilter::MakeValue(mip_filter_cb) | - set_sampler_states::MaxAnisotropy::MakeValue(max_anisotropy_cb); - helper->AddCommand(command_buffer::SET_SAMPLER_STATES, 2, args); + helper->SetSamplerStates( + resource_id_, + address_mode_u_cb, + address_mode_v_cb, + address_mode_w_cb, + mag_filter_cb, + min_filter_cb, + mip_filter_cb, + max_anisotropy_cb); Float4 color = border_color(); - args[1].value_float = color[0]; - args[2].value_float = color[1]; - args[3].value_float = color[2]; - args[4].value_float = color[3]; - helper->AddCommand(command_buffer::SET_SAMPLER_BORDER_COLOR, 5, args); + helper->SetSamplerBorderColor(resource_id_, + color[0], color[1], color[2], color[3]); Texture *texture_object = texture(); if (!texture_object) { @@ -143,9 +135,9 @@ void SamplerCB::SetTextureAndStates() { } if (texture_object) { - args[1].value_uint32 = - reinterpret_cast<ResourceID>(texture_object->GetTextureHandle()); - helper->AddCommand(command_buffer::SET_SAMPLER_TEXTURE, 2, args); + helper->SetSamplerTexture( + resource_id_, + reinterpret_cast<uint32>(texture_object->GetTextureHandle())); } } diff --git a/o3d/core/cross/command_buffer/states_cb.cc b/o3d/core/cross/command_buffer/states_cb.cc index 9126069..c6d4818 100644 --- a/o3d/core/cross/command_buffer/states_cb.cc +++ b/o3d/core/cross/command_buffer/states_cb.cc @@ -441,31 +441,6 @@ class BlendEqStateHandler : public TypedStateHandler<ParamInteger> { bool *dirty_; }; -// A handler that sets the blending color. -// Parameters: -// args: a pointer to the arguments. -// dirty: a pointer to the dirty bit. -class BlendColorStateHandler : public TypedStateHandler<ParamFloat4> { - public: - BlendColorStateHandler(CommandBufferEntry *args, bool *dirty) - : args_(args), - dirty_(dirty) { - } - - virtual void SetStateFromTypedParam(RendererCB* renderer, - ParamFloat4* param) const { - Float4 value = param->value(); - args_[0].value_float = value[0]; - args_[1].value_float = value[1]; - args_[2].value_float = value[2]; - args_[3].value_float = value[3]; - *dirty_ = true; - } - private: - CommandBufferEntry *args_; - bool *dirty_; -}; - // Adds all the state handlers for all the states. The list of handlers must // match in names and types the list in Renderer::AddDefaultStates() // (in renderer.cc). @@ -475,52 +450,58 @@ void RendererCB::StateManager::AddStateHandlers(RendererCB *renderer) { using command_buffer::set_point_line_raster::LineSmoothEnable; using command_buffer::set_point_line_raster::PointSpriteEnable; bool *dirty = point_line_helper_.dirty_ptr(); - uint32 *arg0 = &(point_line_helper_.args()[0].value_uint32); - float *arg1 = &(point_line_helper_.args()[1].value_float); + command_buffer::cmd::SetPointLineRaster& cmd = + point_line_helper_.command(); renderer->AddStateHandler( State::kLineSmoothEnableParamName, - new EnableStateHandler<LineSmoothEnable>(arg0, dirty)); + new EnableStateHandler<LineSmoothEnable>(&cmd.fixme0, dirty)); renderer->AddStateHandler( State::kPointSpriteEnableParamName, - new EnableStateHandler<PointSpriteEnable>(arg0, dirty)); + new EnableStateHandler<PointSpriteEnable>(&cmd.fixme0, dirty)); renderer->AddStateHandler(State::kPointSizeParamName, - new ValueStateHandler<ParamFloat>(arg1, dirty)); + new ValueStateHandler<ParamFloat>( + &cmd.point_size, dirty)); } // Polygon Raster { bool *dirty = poly_raster_helper_.dirty_ptr(); - uint32 *arg = &(poly_raster_helper_.args()[0].value_uint32); + command_buffer::cmd::SetPolygonRaster& cmd = + poly_raster_helper_.command(); renderer->AddStateHandler(State::kCullModeParamName, - new CullModeStateHandler(arg, dirty)); + new CullModeStateHandler(&cmd.fixme0, dirty)); renderer->AddStateHandler(State::kFillModeParamName, - new FillModeStateHandler(arg, dirty)); + new FillModeStateHandler(&cmd.fixme0, dirty)); } // Polygon Offset { bool *dirty = poly_offset_helper_.dirty_ptr(); - float *arg0 = &(poly_offset_helper_.args()[0].value_float); - float *arg1 = &(poly_offset_helper_.args()[1].value_float); - renderer->AddStateHandler(State::kPolygonOffset1ParamName, - new ValueStateHandler<ParamFloat>(arg0, dirty)); - renderer->AddStateHandler(State::kPolygonOffset2ParamName, - new ValueStateHandler<ParamFloat>(arg1, dirty)); + command_buffer::cmd::SetPolygonOffset& cmd = + poly_offset_helper_.command(); + renderer->AddStateHandler( + State::kPolygonOffset1ParamName, + new ValueStateHandler<ParamFloat>(&cmd.slope_factor, dirty)); + renderer->AddStateHandler( + State::kPolygonOffset2ParamName, + new ValueStateHandler<ParamFloat>(&cmd.units, dirty)); } // Alpha test { using command_buffer::set_alpha_test::Enable; using command_buffer::set_alpha_test::Func; + command_buffer::cmd::SetAlphaTest& cmd = alpha_test_helper_.command(); bool *dirty = alpha_test_helper_.dirty_ptr(); - uint32 *arg0 = &(alpha_test_helper_.args()[0].value_uint32); - float *arg1 = &(alpha_test_helper_.args()[1].value_float); - renderer->AddStateHandler(State::kAlphaTestEnableParamName, - new EnableStateHandler<Enable>(arg0, dirty)); - renderer->AddStateHandler(State::kAlphaComparisonFunctionParamName, - new ComparisonStateHandler<Func>(arg0, dirty)); - renderer->AddStateHandler(State::kAlphaReferenceParamName, - new ValueStateHandler<ParamFloat>(arg1, dirty)); + renderer->AddStateHandler( + State::kAlphaTestEnableParamName, + new EnableStateHandler<Enable>(&cmd.fixme0, dirty)); + renderer->AddStateHandler( + State::kAlphaComparisonFunctionParamName, + new ComparisonStateHandler<Func>(&cmd.fixme0, dirty)); + renderer->AddStateHandler( + State::kAlphaReferenceParamName, + new ValueStateHandler<ParamFloat>(&cmd.value, dirty)); } // Depth Test @@ -529,13 +510,16 @@ void RendererCB::StateManager::AddStateHandlers(RendererCB *renderer) { using command_buffer::set_depth_test::WriteEnable; using command_buffer::set_depth_test::Func; bool *dirty = depth_test_helper_.dirty_ptr(); - uint32 *arg = &(depth_test_helper_.args()[0].value_uint32); - renderer->AddStateHandler(State::kZWriteEnableParamName, - new EnableStateHandler<WriteEnable>(arg, dirty)); - renderer->AddStateHandler(State::kZEnableParamName, - new EnableStateHandler<Enable>(arg, dirty)); - renderer->AddStateHandler(State::kZComparisonFunctionParamName, - new ComparisonStateHandler<Func>(arg, dirty)); + command_buffer::cmd::SetDepthTest& cmd = depth_test_helper_.command(); + renderer->AddStateHandler( + State::kZWriteEnableParamName, + new EnableStateHandler<WriteEnable>(&cmd.fixme0, dirty)); + renderer->AddStateHandler( + State::kZEnableParamName, + new EnableStateHandler<Enable>(&cmd.fixme0, dirty)); + renderer->AddStateHandler( + State::kZComparisonFunctionParamName, + new ComparisonStateHandler<Func>(&cmd.fixme0, dirty)); } // Stencil Test @@ -554,42 +538,49 @@ void RendererCB::StateManager::AddStateHandlers(RendererCB *renderer) { using command_buffer::set_stencil_test::CCWFailOp; using command_buffer::set_stencil_test::CCWZFailOp; bool *dirty = stencil_test_helper_.dirty_ptr(); - uint32 *arg0 = &(stencil_test_helper_.args()[0].value_uint32); - uint32 *arg1 = &(stencil_test_helper_.args()[1].value_uint32); - renderer->AddStateHandler(State::kStencilEnableParamName, - new EnableStateHandler<Enable>(arg0, dirty)); - renderer->AddStateHandler(State::kTwoSidedStencilEnableParamName, - new EnableStateHandler<SeparateCCW>(arg0, dirty)); + command_buffer::cmd::SetStencilTest& cmd = stencil_test_helper_.command(); + renderer->AddStateHandler( + State::kStencilEnableParamName, + new EnableStateHandler<Enable>(&cmd.fixme0, dirty)); + renderer->AddStateHandler( + State::kTwoSidedStencilEnableParamName, + new EnableStateHandler<SeparateCCW>(&cmd.fixme0, dirty)); renderer->AddStateHandler( State::kStencilReferenceParamName, - new BitFieldStateHandler<ReferenceValue>(arg0, dirty)); + new BitFieldStateHandler<ReferenceValue>(&cmd.fixme0, dirty)); renderer->AddStateHandler( State::kStencilMaskParamName, - new BitFieldStateHandler<CompareMask>(arg0, dirty)); - renderer->AddStateHandler(State::kStencilWriteMaskParamName, - new BitFieldStateHandler<WriteMask>(arg0, dirty)); + new BitFieldStateHandler<CompareMask>(&cmd.fixme0, dirty)); + renderer->AddStateHandler( + State::kStencilWriteMaskParamName, + new BitFieldStateHandler<WriteMask>(&cmd.fixme0, dirty)); - renderer->AddStateHandler(State::kStencilComparisonFunctionParamName, - new ComparisonStateHandler<CWFunc>(arg1, dirty)); - renderer->AddStateHandler(State::kStencilPassOperationParamName, - new StencilOpStateHandler<CWPassOp>(arg1, dirty)); - renderer->AddStateHandler(State::kStencilFailOperationParamName, - new StencilOpStateHandler<CWFailOp>(arg1, dirty)); + renderer->AddStateHandler( + State::kStencilComparisonFunctionParamName, + new ComparisonStateHandler<CWFunc>(&cmd.fixme1, dirty)); + renderer->AddStateHandler( + State::kStencilPassOperationParamName, + new StencilOpStateHandler<CWPassOp>(&cmd.fixme1, dirty)); + renderer->AddStateHandler( + State::kStencilFailOperationParamName, + new StencilOpStateHandler<CWFailOp>(&cmd.fixme1, dirty)); renderer->AddStateHandler( State::kStencilZFailOperationParamName, - new StencilOpStateHandler<CWZFailOp>(arg1, dirty)); + new StencilOpStateHandler<CWZFailOp>(&cmd.fixme1, dirty)); + + renderer->AddStateHandler( + State::kCCWStencilComparisonFunctionParamName, + new ComparisonStateHandler<CCWFunc>(&cmd.fixme1, dirty)); - renderer->AddStateHandler(State::kCCWStencilComparisonFunctionParamName, - new ComparisonStateHandler<CCWFunc>(arg1, dirty)); renderer->AddStateHandler( State::kCCWStencilPassOperationParamName, - new StencilOpStateHandler<CCWPassOp>(arg1, dirty)); + new StencilOpStateHandler<CCWPassOp>(&cmd.fixme1, dirty)); renderer->AddStateHandler( State::kCCWStencilFailOperationParamName, - new StencilOpStateHandler<CCWFailOp>(arg1, dirty)); + new StencilOpStateHandler<CCWFailOp>(&cmd.fixme1, dirty)); renderer->AddStateHandler( State::kCCWStencilZFailOperationParamName, - new StencilOpStateHandler<CCWZFailOp>(arg1, dirty)); + new StencilOpStateHandler<CCWZFailOp>(&cmd.fixme1, dirty)); } // Blending @@ -603,29 +594,32 @@ void RendererCB::StateManager::AddStateHandlers(RendererCB *renderer) { using command_buffer::set_blending::AlphaSrcFunc; using command_buffer::set_blending::AlphaDstFunc; bool *dirty = blending_helper_.dirty_ptr(); - uint32 *arg = &(blending_helper_.args()[0].value_uint32); - renderer->AddStateHandler(State::kAlphaBlendEnableParamName, - new EnableStateHandler<Enable>(arg, dirty)); + command_buffer::cmd::SetBlending& cmd = blending_helper_.command(); + renderer->AddStateHandler( + State::kAlphaBlendEnableParamName, + new EnableStateHandler<Enable>(&cmd.fixme0, dirty)); renderer->AddStateHandler( State::kSeparateAlphaBlendEnableParamName, - new EnableStateHandler<SeparateAlpha>(arg, dirty)); + new EnableStateHandler<SeparateAlpha>(&cmd.fixme0, dirty)); renderer->AddStateHandler( State::kSourceBlendFunctionParamName, - new BlendFuncStateHandler<ColorSrcFunc>(arg, dirty)); + new BlendFuncStateHandler<ColorSrcFunc>(&cmd.fixme0, dirty)); renderer->AddStateHandler( State::kDestinationBlendFunctionParamName, - new BlendFuncStateHandler<ColorDstFunc>(arg, dirty)); - renderer->AddStateHandler(State::kBlendEquationParamName, - new BlendEqStateHandler<ColorEq>(arg, dirty)); + new BlendFuncStateHandler<ColorDstFunc>(&cmd.fixme0, dirty)); + renderer->AddStateHandler( + State::kBlendEquationParamName, + new BlendEqStateHandler<ColorEq>(&cmd.fixme0, dirty)); renderer->AddStateHandler( State::kSourceBlendAlphaFunctionParamName, - new BlendFuncStateHandler<AlphaSrcFunc>(arg, dirty)); + new BlendFuncStateHandler<AlphaSrcFunc>(&cmd.fixme0, dirty)); renderer->AddStateHandler( State::kDestinationBlendAlphaFunctionParamName, - new BlendFuncStateHandler<AlphaDstFunc>(arg, dirty)); - renderer->AddStateHandler(State::kBlendAlphaEquationParamName, - new BlendEqStateHandler<AlphaEq>(arg, dirty)); + new BlendFuncStateHandler<AlphaDstFunc>(&cmd.fixme0, dirty)); + renderer->AddStateHandler( + State::kBlendAlphaEquationParamName, + new BlendEqStateHandler<AlphaEq>(&cmd.fixme0, dirty)); } // Color Write @@ -633,12 +627,13 @@ void RendererCB::StateManager::AddStateHandlers(RendererCB *renderer) { using command_buffer::set_color_write::DitherEnable; using command_buffer::set_color_write::AllColorsMask; bool *dirty = color_write_helper_.dirty_ptr(); - uint32 *arg = &(color_write_helper_.args()[0].value_uint32); - renderer->AddStateHandler(State::kDitherEnableParamName, - new EnableStateHandler<DitherEnable>(arg, dirty)); + command_buffer::cmd::SetColorWrite& cmd = color_write_helper_.command(); + renderer->AddStateHandler( + State::kDitherEnableParamName, + new EnableStateHandler<DitherEnable>(&cmd.flags, dirty)); renderer->AddStateHandler( State::kColorWriteEnableParamName, - new ColorWriteStateHandler(arg, dirty)); + new ColorWriteStateHandler(&cmd.flags, dirty)); } } @@ -651,7 +646,6 @@ void RendererCB::StateManager::ValidateStates(CommandBufferHelper *helper) { stencil_test_helper_.Validate(helper); color_write_helper_.Validate(helper); blending_helper_.Validate(helper); - blending_color_helper_.Validate(helper); } } // namespace o3d diff --git a/o3d/core/cross/command_buffer/states_cb.h b/o3d/core/cross/command_buffer/states_cb.h index 352e1b0..471f92a 100644 --- a/o3d/core/cross/command_buffer/states_cb.h +++ b/o3d/core/cross/command_buffer/states_cb.h @@ -59,41 +59,43 @@ class RendererCB::StateManager { // A template helper. This wraps a command sent to set a set of states. It // keeps all the arguments of a single command, that get modified by the // various handles, as well as a dirty bit. - template <command_buffer::CommandId command, unsigned int arg_count> + template <typename CommandType> class StateHelper { public: - static const unsigned int kArgCount = arg_count; - StateHelper() : dirty_(false) { - for (unsigned int i = 0; i < kArgCount; ++i) { - args_[i].value_uint32 = 0; - } + // NOTE: This code assumes the state commands only need their + // header set and that the rest will be set by the state handlers. + memset(&command_, 0, sizeof(command_)); + command_.SetHeader(); } // Sends the command if it is marked as dirty. void Validate(command_buffer::CommandBufferHelper *helper) { if (!dirty_) return; - helper->AddCommand(command, kArgCount, args_); + helper->AddTypedCmdData(command_); dirty_ = false; } - command_buffer::CommandBufferEntry *args() { return args_; } + CommandType& command() { + return command_; + } + bool *dirty_ptr() { return &dirty_; } private: bool dirty_; - command_buffer::CommandBufferEntry args_[kArgCount]; + CommandType command_; DISALLOW_COPY_AND_ASSIGN(StateHelper); }; - StateHelper<command_buffer::SET_POINT_LINE_RASTER, 2> point_line_helper_; - StateHelper<command_buffer::SET_POLYGON_OFFSET, 2> poly_offset_helper_; - StateHelper<command_buffer::SET_POLYGON_RASTER, 1> poly_raster_helper_; - StateHelper<command_buffer::SET_ALPHA_TEST, 2> alpha_test_helper_; - StateHelper<command_buffer::SET_DEPTH_TEST, 1> depth_test_helper_; - StateHelper<command_buffer::SET_STENCIL_TEST, 2> stencil_test_helper_; - StateHelper<command_buffer::SET_COLOR_WRITE, 1> color_write_helper_; - StateHelper<command_buffer::SET_BLENDING, 1> blending_helper_; - StateHelper<command_buffer::SET_BLENDING_COLOR, 4> blending_color_helper_; + StateHelper<command_buffer::cmd::SetPointLineRaster> point_line_helper_; + StateHelper<command_buffer::cmd::SetPolygonOffset> poly_offset_helper_; + StateHelper<command_buffer::cmd::SetPolygonRaster> poly_raster_helper_; + StateHelper<command_buffer::cmd::SetAlphaTest> alpha_test_helper_; + StateHelper<command_buffer::cmd::SetDepthTest> depth_test_helper_; + StateHelper<command_buffer::cmd::SetStencilTest> stencil_test_helper_; + StateHelper<command_buffer::cmd::SetColorWrite> color_write_helper_; + StateHelper<command_buffer::cmd::SetBlending> blending_helper_; + StateHelper<command_buffer::cmd::SetBlendingColor> blending_color_helper_; DISALLOW_COPY_AND_ASSIGN(StateManager); }; diff --git a/o3d/core/cross/command_buffer/stream_bank_cb.cc b/o3d/core/cross/command_buffer/stream_bank_cb.cc index 42b9158..1ddca52 100644 --- a/o3d/core/cross/command_buffer/stream_bank_cb.cc +++ b/o3d/core/cross/command_buffer/stream_bank_cb.cc @@ -147,10 +147,7 @@ void StreamBankCB::CreateVertexStruct() { DCHECK_EQ(kInvalidResource, vertex_struct_id_); vertex_struct_id_ = renderer_->vertex_structs_ids().AllocateID(); CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[5]; - args[0].value_uint32 = vertex_struct_id_; - args[1].value_uint32 = vertex_stream_params_.size(); - helper->AddCommand(command_buffer::CREATE_VERTEX_STRUCT, 2, args); + helper->CreateVertexStruct(vertex_struct_id_, vertex_stream_params_.size()); for (unsigned int i = 0; i < vertex_stream_params_.size(); ++i) { const Stream &stream = vertex_stream_params_[i]->stream(); vertex_struct::Semantic cb_semantic; @@ -168,19 +165,16 @@ void StreamBankCB::CreateVertexStruct() { continue; } - namespace cmd = command_buffer::set_vertex_input_cmd; VertexBufferCB *vertex_buffer = static_cast<VertexBufferCB *>(stream.field().buffer()); - args[0].value_uint32 = vertex_struct_id_; - args[1].value_uint32 = i; - args[2].value_uint32 = vertex_buffer->resource_id(); - args[3].value_uint32 = stream.field().offset(); - args[4].value_uint32 = - cmd::SemanticIndex::MakeValue(cb_semantic_index) | - cmd::Semantic::MakeValue(cb_semantic) | - cmd::Type::MakeValue(cb_type) | - cmd::Stride::MakeValue(vertex_buffer->stride()); - helper->AddCommand(command_buffer::SET_VERTEX_INPUT, 5, args); + helper->SetVertexInput( + vertex_struct_id_, i, + vertex_buffer->resource_id(), + stream.field().offset(), + cb_semantic, + cb_semantic_index, + cb_type, + vertex_buffer->stride()); } } @@ -188,9 +182,7 @@ void StreamBankCB::CreateVertexStruct() { void StreamBankCB::DestroyVertexStruct() { if (vertex_struct_id_ != kInvalidResource) { CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[1]; - args[0].value_uint32 = vertex_struct_id_; - helper->AddCommand(command_buffer::DESTROY_VERTEX_STRUCT, 1, args); + helper->DestroyVertexStruct(vertex_struct_id_); renderer_->vertex_structs_ids().FreeID(vertex_struct_id_); vertex_struct_id_ = kInvalidResource; } @@ -200,10 +192,7 @@ void StreamBankCB::BindStreamsForRendering() { if (vertex_struct_id_ == kInvalidResource) CreateVertexStruct(); CommandBufferHelper *helper = renderer_->helper(); - CommandBufferEntry args[6]; - // Sets current vertex struct. - args[0].value_uint32 = vertex_struct_id_; - helper->AddCommand(command_buffer::SET_VERTEX_STRUCT, 1, args); + helper->SetVertexStruct(vertex_struct_id_); } } // namespace o3d diff --git a/o3d/core/cross/command_buffer/texture_cb.cc b/o3d/core/cross/command_buffer/texture_cb.cc index 12e3d98..d00a094 100644 --- a/o3d/core/cross/command_buffer/texture_cb.cc +++ b/o3d/core/cross/command_buffer/texture_cb.cc @@ -120,7 +120,7 @@ void SetTextureDataBuffer(Texture::Format format, } } -// Sends the SET_TEXTURE_DATA command after formatting the args properly. +// Sends the SetTextureData command after formatting the args properly. void SetTextureData(RendererCB *renderer, ResourceID texture_id, unsigned int x, @@ -136,27 +136,16 @@ void SetTextureData(RendererCB *renderer, unsigned char* mip_data) { FencedAllocatorWrapper *allocator = renderer->allocator(); CommandBufferHelper *helper = renderer->helper(); - - CommandBufferEntry args[10]; - args[0].value_uint32 = texture_id; - args[1].value_uint32 = - set_texture_data_cmd::X::MakeValue(x) | - set_texture_data_cmd::Y::MakeValue(y); - args[2].value_uint32 = - set_texture_data_cmd::Width::MakeValue(mip_width) | - set_texture_data_cmd::Height::MakeValue(mip_height); - args[3].value_uint32 = - set_texture_data_cmd::Z::MakeValue(z) | - set_texture_data_cmd::Depth::MakeValue(depth); - args[4].value_uint32 = - set_texture_data_cmd::Level::MakeValue(level) | - set_texture_data_cmd::Face::MakeValue(face); - args[5].value_uint32 = pitch; - args[6].value_uint32 = 0; // slice_pitch - args[7].value_uint32 = mip_size; - args[8].value_uint32 = renderer->transfer_shm_id(); - args[9].value_uint32 = allocator->GetOffset(mip_data); - helper->AddCommand(command_buffer::SET_TEXTURE_DATA, 10, args); + helper->SetTextureData( + texture_id, + x, y, z, + mip_width, mip_height, depth, + level, face, + pitch, + 0, // slice_pitch + mip_size, + renderer->transfer_shm_id(), + allocator->GetOffset(mip_data)); allocator->FreePendingToken(mip_data, helper->InsertToken()); } // Updates a command buffer texture resource from a bitmap, rescaling if @@ -213,26 +202,21 @@ void CopyBackResourceToBitmap(RendererCB *renderer, size_t pitch = image::ComputeBufferSize(mip_width, 1, bitmap.format()); - CommandBufferEntry args[10]; - args[0].value_uint32 = texture_id; - args[1].value_uint32 = - get_texture_data_cmd::X::MakeValue(0) | - get_texture_data_cmd::Y::MakeValue(0); - args[2].value_uint32 = - get_texture_data_cmd::Width::MakeValue(mip_width) | - get_texture_data_cmd::Height::MakeValue(mip_height); - args[3].value_uint32 = - get_texture_data_cmd::Z::MakeValue(0) | - get_texture_data_cmd::Depth::MakeValue(1); - args[4].value_uint32 = - get_texture_data_cmd::Level::MakeValue(level) | - get_texture_data_cmd::Face::MakeValue(face); - args[5].value_uint32 = pitch; - args[6].value_uint32 = 0; // slice_pitch - args[7].value_uint32 = mip_size; - args[8].value_uint32 = renderer->transfer_shm_id(); - args[9].value_uint32 = allocator->GetOffset(buffer); - helper->AddCommand(command_buffer::GET_TEXTURE_DATA, 10, args); + helper->GetTextureData( + texture_id, + 0, + 0, + 0, + mip_width, + mip_height, + 1, + level, + face, + pitch, + 0, + mip_size, + renderer->transfer_shm_id(), + allocator->GetOffset(buffer)); helper->Finish(); memcpy(bitmap.GetMipData(level), buffer, mip_size); allocator->Free(buffer); @@ -272,9 +256,7 @@ Texture2DCB::Texture2DCB(ServiceLocator* service_locator, Texture2DCB::~Texture2DCB() { if (resource_id_ != command_buffer::kInvalidResource) { - CommandBufferEntry args[1]; - args[0].value_uint32 = resource_id_; - renderer_->helper()->AddCommand(command_buffer::DESTROY_TEXTURE, 1, args); + renderer_->helper()->DestroyTexture(resource_id_); } } @@ -301,16 +283,10 @@ Texture2DCB* Texture2DCB::Create(ServiceLocator* service_locator, } ResourceID texture_id = renderer->texture_ids().AllocateID(); - CommandBufferEntry args[3]; - args[0].value_uint32 = texture_id; - args[1].value_uint32 = - create_texture_2d_cmd::Width::MakeValue(width) | - create_texture_2d_cmd::Height::MakeValue(height); - args[2].value_uint32 = - create_texture_2d_cmd::Levels::MakeValue(levels) | - create_texture_2d_cmd::Format::MakeValue(cb_format) | - create_texture_2d_cmd::Flags::MakeValue(enable_render_surfaces); - renderer->helper()->AddCommand(command_buffer::CREATE_TEXTURE_2D, 3, args); + renderer->helper()->CreateTexture2d( + texture_id, + width, height, + levels, cb_format, enable_render_surfaces); Texture2DCB *texture = new Texture2DCB(service_locator, texture_id, format, levels, width, height, @@ -496,9 +472,7 @@ TextureCUBECB::TextureCUBECB(ServiceLocator* service_locator, TextureCUBECB::~TextureCUBECB() { if (resource_id_ != command_buffer::kInvalidResource) { - CommandBufferEntry args[1]; - args[0].value_uint32 = resource_id_; - renderer_->helper()->AddCommand(command_buffer::DESTROY_TEXTURE, 1, args); + renderer_->helper()->DestroyTexture(resource_id_); } } @@ -524,14 +498,10 @@ TextureCUBECB* TextureCUBECB::Create(ServiceLocator* service_locator, } ResourceID texture_id = renderer->texture_ids().AllocateID(); - CommandBufferEntry args[3]; - args[0].value_uint32 = texture_id; - args[1].value_uint32 = create_texture_cube_cmd::Side::MakeValue(edge_length); - args[2].value_uint32 = - create_texture_cube_cmd::Levels::MakeValue(levels) | - create_texture_cube_cmd::Format::MakeValue(cb_format) | - create_texture_cube_cmd::Flags::MakeValue(enable_render_surfaces); - renderer->helper()->AddCommand(command_buffer::CREATE_TEXTURE_CUBE, 3, args); + renderer->helper()->CreateTextureCube( + texture_id, + edge_length, + levels, cb_format, enable_render_surfaces); TextureCUBECB* texture = new TextureCUBECB(service_locator, texture_id, format, levels, |