encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Make dawn_wire a shared library 

Also moves the TerribleCommandBuffer to utils:: because it isn't part of
the implementation of the wire, renames dawn::wire to dawn_wire, moves
src/wire to src/dawn_wire and puts the interface of dawn_wire in
src/include/dawn_wire.
This commit is contained in:
Corentin Wallez 2018-07-26 15:07:57 +02:00 committed by Corentin Wallez
parent 012c149fd9
commit bdc867713a
18 changed files with 154 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -238,7 +238,7 @@ add_subdirectory(third_party)
add_subdirectory(src/common)
add_subdirectory(src/dawn_native)
add_subdirectory(src/wire)
add_subdirectory(src/dawn_wire)
add_subdirectory(src/utils)
add_subdirectory(src/tests)

18
examples/SampleUtils.cpp
View File

@ -17,7 +17,7 @@
#include "common/Assert.h"
#include "common/Platform.h"
#include "utils/BackendBinding.h"
#include "wire/TerribleCommandBuffer.h"
#include "utils/TerribleCommandBuffer.h"
#include <dawn/dawn.h>
#include <dawn/dawncpp.h>
@ -60,10 +60,10 @@ static utils::BackendBinding* binding = nullptr;
static GLFWwindow* window = nullptr;
static dawn::wire::CommandHandler* wireServer = nullptr;
static dawn::wire::CommandHandler* wireClient = nullptr;
static dawn::wire::TerribleCommandBuffer* c2sBuf = nullptr;
static dawn::wire::TerribleCommandBuffer* s2cBuf = nullptr;
static dawn_wire::CommandHandler* wireServer = nullptr;
static dawn_wire::CommandHandler* wireClient = nullptr;
static utils::TerribleCommandBuffer* c2sBuf = nullptr;
static utils::TerribleCommandBuffer* s2cBuf = nullptr;
dawn::Device CreateCppDawnDevice() {
binding = utils::CreateBinding(backendType);
@ -98,15 +98,15 @@ dawn::Device CreateCppDawnDevice() {
case CmdBufType::Terrible:
{
c2sBuf = new dawn::wire::TerribleCommandBuffer();
s2cBuf = new dawn::wire::TerribleCommandBuffer();
c2sBuf = new utils::TerribleCommandBuffer();
s2cBuf = new utils::TerribleCommandBuffer();
wireServer = dawn::wire::NewServerCommandHandler(backendDevice, backendProcs, s2cBuf);
wireServer = dawn_wire::NewServerCommandHandler(backendDevice, backendProcs, s2cBuf);
c2sBuf->SetHandler(wireServer);
dawnDevice clientDevice;
dawnProcTable clientProcs;
wireClient = dawn::wire::NewClientDevice(&clientProcs, &clientDevice, c2sBuf);
wireClient = dawn_wire::NewClientDevice(&clientProcs, &clientDevice, c2sBuf);
s2cBuf->SetHandler(wireClient);
procs = clientProcs;

12
generator/main.py
View File

@ -389,7 +389,7 @@ def debug(text):
print(text)
def main():
targets = ['dawn_headers', 'libdawn', 'mock_dawn', 'opengl', 'metal', 'd3d12', 'null', 'wire', "dawn_native_utils"]
targets = ['dawn_headers', 'libdawn', 'mock_dawn', 'opengl', 'metal', 'd3d12', 'null', 'dawn_wire', "dawn_native_utils"]
parser = argparse.ArgumentParser(
description = 'Generates code for various target for Dawn.',
@ -482,11 +482,11 @@ def main():
renders.append(FileRender('dawn_native/api_structs.h', 'dawn_native/dawn_structs_autogen.h', base_backend_params))
renders.append(FileRender('dawn_native/api_structs.cpp', 'dawn_native/dawn_structs_autogen.cpp', base_backend_params))
if 'wire' in targets:
renders.append(FileRender('wire/WireCmd.h', 'wire/WireCmd_autogen.h', base_backend_params))
renders.append(FileRender('wire/WireCmd.cpp', 'wire/WireCmd_autogen.cpp', base_backend_params))
renders.append(FileRender('wire/WireClient.cpp', 'wire/WireClient.cpp', base_backend_params))
renders.append(FileRender('wire/WireServer.cpp', 'wire/WireServer.cpp', base_backend_params))
if 'dawn_wire' in targets:
renders.append(FileRender('dawn_wire/WireCmd.h', 'dawn_wire/WireCmd_autogen.h', base_backend_params))
renders.append(FileRender('dawn_wire/WireCmd.cpp', 'dawn_wire/WireCmd_autogen.cpp', base_backend_params))
renders.append(FileRender('dawn_wire/WireClient.cpp', 'dawn_wire/WireClient.cpp', base_backend_params))
renders.append(FileRender('dawn_wire/WireServer.cpp', 'dawn_wire/WireServer.cpp', base_backend_params))
output_separator = '\n' if args.gn else ';'
if args.print_dependencies:

20
generator/templates/wire/WireClient.cpp → generator/templates/dawn_wire/WireClient.cpp
View File

@ -12,8 +12,8 @@
//* See the License for the specific language governing permissions and
//* limitations under the License.
#include "wire/Wire.h"
#include "wire/WireCmd.h"
#include "dawn_wire/Wire.h"
#include "dawn_wire/WireCmd.h"
#include "common/Assert.h"
@ -24,7 +24,7 @@
#include <string>
#include <vector>
namespace dawn { namespace wire {
namespace dawn_wire {
//* Client side implementation of the API, will serialize everything to memory to send to the server side.
namespace client {
@ -194,7 +194,7 @@ namespace dawn { namespace wire {
//* The client wire uses the global Dawn device to store its global data such as the serializer
//* and the object id allocators.
class Device : public ObjectBase, public wire::ObjectIdProvider {
class Device : public ObjectBase, public ObjectIdProvider {
public:
Device(CommandSerializer* serializer)
: ObjectBase(this, 1, 1),
@ -247,7 +247,7 @@ namespace dawn { namespace wire {
) {
{{as_backendType(type)}} self = reinterpret_cast<{{as_backendType(type)}}>(cSelf);
Device* device = self->device;
wire::{{Suffix}}Cmd cmd;
{{Suffix}}Cmd cmd;
//* Create the structure going on the wire on the stack and fill it with the value
//* arguments so it can compute its size.
@ -306,7 +306,7 @@ namespace dawn { namespace wire {
obj->builderCallback.Call(DAWN_BUILDER_ERROR_STATUS_UNKNOWN, "Unknown");
wire::{{as_MethodSuffix(type.name, Name("destroy"))}}Cmd cmd;
{{as_MethodSuffix(type.name, Name("destroy"))}}Cmd cmd;
cmd.objectId = obj->id;
auto allocCmd = static_cast<decltype(cmd)*>(obj->device->GetCmdSpace(sizeof(cmd)));
@ -332,7 +332,7 @@ namespace dawn { namespace wire {
request.isWrite = false;
buffer->requests[serial] = request;
wire::BufferMapAsyncCmd cmd;
BufferMapAsyncCmd cmd;
cmd.bufferId = buffer->id;
cmd.requestSerial = serial;
cmd.start = start;
@ -354,7 +354,7 @@ namespace dawn { namespace wire {
request.isWrite = true;
buffer->requests[serial] = request;
wire::BufferMapAsyncCmd cmd;
BufferMapAsyncCmd cmd;
cmd.bufferId = buffer->id;
cmd.requestSerial = serial;
cmd.start = start;
@ -379,7 +379,7 @@ namespace dawn { namespace wire {
// If the buffer was mapped for writing, send the update to the data to the server
if (buffer->isWriteMapped) {
wire::BufferUpdateMappedDataCmd cmd;
BufferUpdateMappedDataCmd cmd;
cmd.bufferId = buffer->id;
cmd.dataLength = static_cast<uint32_t>(buffer->mappedDataSize);
@ -673,4 +673,4 @@ namespace dawn { namespace wire {
return new client::Client(clientDevice);
}
}} // namespace dawn::wire
} // namespace dawn_wire

12
generator/templates/wire/WireCmd.cpp → generator/templates/dawn_wire/WireCmd.cpp
View File

@ -12,7 +12,7 @@
//* See the License for the specific language governing permissions and
//* limitations under the License.
#include "wire/WireCmd.h"
#include "dawn_wire/WireCmd.h"
#include "common/Assert.h"
@ -83,7 +83,7 @@
struct {{name}}Transfer {
{% if is_method %}
//* Start the transfer structure with the command ID, so that casting to WireCmd gives the ID.
wire::{{Return}}WireCmd commandId;
{{Return}}WireCmd commandId;
//* Methods always have an implicit "self" argument.
ObjectId self;
@ -150,7 +150,7 @@
transfer->resultSerial = record.resultSerial;
{% endif %}
transfer->commandId = wire::{{Return}}WireCmd::{{name}};
transfer->commandId = {{Return}}WireCmd::{{name}};
transfer->self = provider.GetId(record.self);
{% endif %}
@ -201,7 +201,7 @@
record->resultSerial = transfer->resultSerial;
{% endif %}
ASSERT(transfer->commandId == wire::{{Return}}WireCmd::{{name}});
ASSERT(transfer->commandId == {{Return}}WireCmd::{{name}});
record->selfId = transfer->self;
//* This conversion is done after the copying of result* and selfId: Deserialize
@ -258,7 +258,7 @@
}
{% endmacro %}
namespace dawn { namespace wire {
namespace dawn_wire {
// Macro to simplify error handling, similar to DAWN_TRY but for DeserializeResult.
#define DESERIALIZE_TRY(EXPR) \
@ -344,4 +344,4 @@ namespace dawn { namespace wire {
{% endfor %}
{% endfor %}
}} // namespace dawn::wire
} // namespace dawn_wire

12
generator/templates/wire/WireCmd.h → generator/templates/dawn_wire/WireCmd.h
View File

@ -12,10 +12,10 @@
//* See the License for the specific language governing permissions and
//* limitations under the License.
#ifndef WIRE_WIRECMD_AUTOGEN_H_
#define WIRE_WIRECMD_AUTOGEN_H_
#ifndef DAWNWIRE_WIRECMD_AUTOGEN_H_
#define DAWNWIRE_WIRECMD_AUTOGEN_H_
namespace dawn { namespace wire {
namespace dawn_wire {
using ObjectId = uint32_t;
using ObjectSerial = uint32_t;
@ -131,7 +131,7 @@ namespace dawn { namespace wire {
//* Command for the server calling a builder status callback.
{% for type in by_category["object"] if type.is_builder %}
struct Return{{type.name.CamelCase()}}ErrorCallbackCmd {
wire::ReturnWireCmd commandId = ReturnWireCmd::{{type.name.CamelCase()}}ErrorCallback;
ReturnWireCmd commandId = ReturnWireCmd::{{type.name.CamelCase()}}ErrorCallback;
ObjectId builtObjectId;
ObjectSerial builtObjectSerial;
@ -140,6 +140,6 @@ namespace dawn { namespace wire {
};
{% endfor %}
}} // namespace dawn::wire
} // namespace dawn_wire
#endif // WIRE_WIRECMD_AUTOGEN_H_
#endif // DAWNWIRE_WIRECMD_AUTOGEN_H_

8
generator/templates/wire/WireServer.cpp → generator/templates/dawn_wire/WireServer.cpp
View File

@ -12,8 +12,8 @@
//* See the License for the specific language governing permissions and
//* limitations under the License.
#include "wire/Wire.h"
#include "wire/WireCmd.h"
#include "dawn_wire/Wire.h"
#include "dawn_wire/WireCmd.h"
#include "common/Assert.h"
@ -22,7 +22,7 @@
#include <cstring>
#include <vector>
namespace dawn { namespace wire {
namespace dawn_wire {
namespace server {
class Server;
@ -626,4 +626,4 @@ namespace dawn { namespace wire {
return new server::Server(device, procs, serializer);
}
}} // namespace dawn::wire
} // namespace dawn_wire

24
src/wire/CMakeLists.txt → src/dawn_wire/CMakeLists.txt
View File

@ -12,24 +12,26 @@
# See the License for the specific language governing permissions and
# limitations under the License.
set(WIRE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
set(DAWN_WIRE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
set(DAWN_WIRE_INCLUDE_DIR ${INCLUDE_DIR}/dawn_wire)
Generate(
LIB_NAME dawn_wire_autogen
LIB_TYPE STATIC
LIB_TYPE OBJECT
FOLDER "wire"
PRINT_NAME "Wire serialization/deserialization autogenerated files"
PRINT_NAME "dawn_wire autogenerated files"
COMMAND_LINE_ARGS
${GENERATOR_COMMON_ARGS}
-T wire
EXTRA_SOURCES
${WIRE_DIR}/WireCmd.h
-T dawn_wire
)
target_compile_definitions(dawn_wire_autogen PRIVATE DAWN_WIRE_IMPLEMENTATION)
add_library(dawn_wire STATIC
${WIRE_DIR}/TerribleCommandBuffer.cpp
${WIRE_DIR}/TerribleCommandBuffer.h
${WIRE_DIR}/Wire.h
add_library(dawn_wire SHARED
$<TARGET_OBJECTS:dawn_wire_autogen>
${DAWN_WIRE_DIR}/WireCmd.h
${DAWN_WIRE_INCLUDE_DIR}/Wire.h
${DAWN_WIRE_INCLUDE_DIR}/dawn_wire_export.h
)
target_link_libraries(dawn_wire dawn_wire_autogen dawn_common)
target_link_libraries(dawn_wire dawn_common)
target_compile_definitions(dawn_wire PRIVATE DAWN_WIRE_IMPLEMENTATION)
DawnInternalTarget("wire" dawn_wire)

22
src/wire/WireCmd.h → src/dawn_wire/WireCmd.h
View File

@ -12,23 +12,23 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef WIRE_WIRECMD_H_
#define WIRE_WIRECMD_H_
#ifndef DAWNWIRE_WIRECMD_H_
#define DAWNWIRE_WIRECMD_H_
#include <dawn/dawn.h>
#include "wire/WireCmd_autogen.h"
#include "dawn_wire/WireCmd_autogen.h"
namespace dawn { namespace wire {
namespace dawn_wire {
struct ReturnDeviceErrorCallbackCmd {
wire::ReturnWireCmd commandId = ReturnWireCmd::DeviceErrorCallback;
ReturnWireCmd commandId = ReturnWireCmd::DeviceErrorCallback;
size_t messageStrlen;
};
struct BufferMapAsyncCmd {
wire::WireCmd commandId = WireCmd::BufferMapAsync;
WireCmd commandId = WireCmd::BufferMapAsync;
ObjectId bufferId;
ObjectSerial requestSerial;
@ -38,7 +38,7 @@ namespace dawn { namespace wire {
};
struct ReturnBufferMapReadAsyncCallbackCmd {
wire::ReturnWireCmd commandId = ReturnWireCmd::BufferMapReadAsyncCallback;
ReturnWireCmd commandId = ReturnWireCmd::BufferMapReadAsyncCallback;
ObjectId bufferId;
ObjectSerial bufferSerial;
@ -48,7 +48,7 @@ namespace dawn { namespace wire {
};
struct ReturnBufferMapWriteAsyncCallbackCmd {
wire::ReturnWireCmd commandId = ReturnWireCmd::BufferMapWriteAsyncCallback;
ReturnWireCmd commandId = ReturnWireCmd::BufferMapWriteAsyncCallback;
ObjectId bufferId;
ObjectSerial bufferSerial;
@ -57,12 +57,12 @@ namespace dawn { namespace wire {
};
struct BufferUpdateMappedDataCmd {
wire::WireCmd commandId = WireCmd::BufferUpdateMappedDataCmd;
WireCmd commandId = WireCmd::BufferUpdateMappedDataCmd;
ObjectId bufferId;
uint32_t dataLength;
};
}} // namespace dawn::wire
} // namespace dawn_wire
#endif // WIRE_WIRECMD_H_
#endif // DAWNWIRE_WIRECMD_H_

27
src/wire/Wire.h → src/include/dawn_wire/Wire.h
View File

@ -12,35 +12,36 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef WIRE_WIRE_H_
#define WIRE_WIRE_H_
#ifndef DAWNWIRE_WIRE_H_
#define DAWNWIRE_WIRE_H_
#include <cstdint>
#include "dawn/dawn.h"
#include "dawn_wire/dawn_wire_export.h"
namespace dawn { namespace wire {
namespace dawn_wire {
class CommandSerializer {
class DAWN_WIRE_EXPORT CommandSerializer {
public:
virtual ~CommandSerializer() = default;
virtual void* GetCmdSpace(size_t size) = 0;
virtual bool Flush() = 0;
};
class CommandHandler {
class DAWN_WIRE_EXPORT CommandHandler {
public:
virtual ~CommandHandler() = default;
virtual const char* HandleCommands(const char* commands, size_t size) = 0;
};
CommandHandler* NewClientDevice(dawnProcTable* procs,
dawnDevice* device,
CommandSerializer* serializer);
CommandHandler* NewServerCommandHandler(dawnDevice device,
const dawnProcTable& procs,
CommandSerializer* serializer);
DAWN_WIRE_EXPORT CommandHandler* NewClientDevice(dawnProcTable* procs,
dawnDevice* device,
CommandSerializer* serializer);
DAWN_WIRE_EXPORT CommandHandler* NewServerCommandHandler(dawnDevice device,
const dawnProcTable& procs,
CommandSerializer* serializer);
}} // namespace dawn::wire
} // namespace dawn_wire
#endif // WIRE_WIRE_H_
#endif // DAWNWIRE_WIRE_H_

32
src/include/dawn_wire/dawn_wire_export.h Normal file
View File

@ -0,0 +1,32 @@
// Copyright 2018 The Dawn Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef DAWNWIRE_EXPORT_H_
#define DAWNWIRE_EXPORT_H_
#if defined(WIN32)
# if defined(DAWN_WIRE_IMPLEMENTATION)
# define DAWN_WIRE_EXPORT __declspec(dllexport)
# else
# define DAWN_WIRE_EXPORT __declspec(dllimport)
# endif
#else
# if defined(DAWN_WIRE_IMPLEMENTATION)
# define DAWN_WIRE_EXPORT __attribute__((visibility("default")))
# else
# define DAWN_WIRE_EXPORT
# endif
#endif
#endif // DAWNWIRE_EXPORT_H_

12
src/tests/DawnTest.cpp
View File

@ -17,11 +17,11 @@
#include "common/Assert.h"
#include "common/Constants.h"
#include "common/Math.h"
#include "dawn_wire/Wire.h"
#include "utils/BackendBinding.h"
#include "utils/DawnHelpers.h"
#include "utils/SystemUtils.h"
#include "wire/TerribleCommandBuffer.h"
#include "wire/Wire.h"
#include "utils/TerribleCommandBuffer.h"
#include <iostream>
#include "GLFW/glfw3.h"
@ -145,15 +145,15 @@ void DawnTest::SetUp() {
dawnProcTable procs;
if (gTestUsesWire) {
mC2sBuf = new dawn::wire::TerribleCommandBuffer();
mS2cBuf = new dawn::wire::TerribleCommandBuffer();
mC2sBuf = new utils::TerribleCommandBuffer();
mS2cBuf = new utils::TerribleCommandBuffer();
mWireServer = dawn::wire::NewServerCommandHandler(backendDevice, backendProcs, mS2cBuf);
mWireServer = dawn_wire::NewServerCommandHandler(backendDevice, backendProcs, mS2cBuf);
mC2sBuf->SetHandler(mWireServer);
dawnDevice clientDevice;
dawnProcTable clientProcs;
mWireClient = dawn::wire::NewClientDevice(&clientProcs, &clientDevice, mC2sBuf);
mWireClient = dawn_wire::NewClientDevice(&clientProcs, &clientDevice, mC2sBuf);
mS2cBuf->SetHandler(mWireClient);
procs = clientProcs;

14
src/tests/DawnTest.h
View File

@ -66,16 +66,16 @@ std::ostream& operator<<(std::ostream& stream, BackendType backend);
namespace utils {
class BackendBinding;
class TerribleCommandBuffer;
}
namespace detail {
class Expectation;
}
namespace dawn { namespace wire {
namespace dawn_wire {
class CommandHandler;
class TerribleCommandBuffer;
}} // namespace dawn::wire
} // namespace dawn_wire
class DawnTest : public ::testing::TestWithParam<BackendType> {
public:
@ -118,10 +118,10 @@ class DawnTest : public ::testing::TestWithParam<BackendType> {
private:
// Things used to set up testing through the Wire.
dawn::wire::CommandHandler* mWireServer = nullptr;
dawn::wire::CommandHandler* mWireClient = nullptr;
dawn::wire::TerribleCommandBuffer* mC2sBuf = nullptr;
dawn::wire::TerribleCommandBuffer* mS2cBuf = nullptr;
dawn_wire::CommandHandler* mWireServer = nullptr;
dawn_wire::CommandHandler* mWireClient = nullptr;
utils::TerribleCommandBuffer* mC2sBuf = nullptr;
utils::TerribleCommandBuffer* mS2cBuf = nullptr;
void FlushWire();
// MapRead buffers used to get data for the expectations

14
src/tests/unittests/WireTests.cpp
View File

@ -16,11 +16,11 @@
#include "mock/mock_dawn.h"
#include "common/Assert.h"
#include "wire/TerribleCommandBuffer.h"
#include "wire/Wire.h"
#include "dawn_wire/Wire.h"
#include "utils/TerribleCommandBuffer.h"
using namespace testing;
using namespace dawn::wire;
using namespace dawn_wire;
// Definition of a "Lambda predicate matcher" for GMock to allow checking deep structures
// are passed correctly by the wire.
@ -138,8 +138,8 @@ class WireTestsBase : public Test {
}
EXPECT_CALL(api, DeviceTick(_)).Times(AnyNumber());
mS2cBuf = new TerribleCommandBuffer();
mC2sBuf = new TerribleCommandBuffer(mWireServer);
mS2cBuf = new utils::TerribleCommandBuffer();
mC2sBuf = new utils::TerribleCommandBuffer(mWireServer);
mWireServer = NewServerCommandHandler(mockDevice, mockProcs, mS2cBuf);
mC2sBuf->SetHandler(mWireServer);
@ -181,8 +181,8 @@ class WireTestsBase : public Test {
CommandHandler* mWireServer = nullptr;
CommandHandler* mWireClient = nullptr;
TerribleCommandBuffer* mS2cBuf = nullptr;
TerribleCommandBuffer* mC2sBuf = nullptr;
utils::TerribleCommandBuffer* mS2cBuf = nullptr;
utils::TerribleCommandBuffer* mC2sBuf = nullptr;
};
class WireTests : public WireTestsBase {

2
src/utils/CMakeLists.txt
View File

@ -21,6 +21,8 @@ list(APPEND UTILS_SOURCES
${UTILS_DIR}/DawnHelpers.h
${UTILS_DIR}/SystemUtils.cpp
${UTILS_DIR}/SystemUtils.h
${UTILS_DIR}/TerribleCommandBuffer.cpp
${UTILS_DIR}/TerribleCommandBuffer.h
)
if (DAWN_ENABLE_D3D12)

11
src/wire/TerribleCommandBuffer.cpp → src/utils/TerribleCommandBuffer.cpp
View File

@ -12,19 +12,20 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#include "wire/TerribleCommandBuffer.h"
#include "utils/TerribleCommandBuffer.h"
#include "common/Assert.h"
namespace dawn { namespace wire {
namespace utils {
TerribleCommandBuffer::TerribleCommandBuffer() {
}
TerribleCommandBuffer::TerribleCommandBuffer(CommandHandler* handler) : mHandler(handler) {
TerribleCommandBuffer::TerribleCommandBuffer(dawn_wire::CommandHandler* handler)
: mHandler(handler) {
}
void TerribleCommandBuffer::SetHandler(CommandHandler* handler) {
void TerribleCommandBuffer::SetHandler(dawn_wire::CommandHandler* handler) {
mHandler = handler;
}
@ -56,4 +57,4 @@ namespace dawn { namespace wire {
return success;
}
}} // namespace dawn::wire
} // namespace utils

20
src/wire/TerribleCommandBuffer.h → src/utils/TerribleCommandBuffer.h
View File

@ -12,31 +12,31 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef WIRE_TERRIBLE_COMMAND_BUFFER_H_
#define WIRE_TERRIBLE_COMMAND_BUFFER_H_
#ifndef UTILS_TERRIBLE_COMMAND_BUFFER_H_
#define UTILS_TERRIBLE_COMMAND_BUFFER_H_
#include <vector>
#include "wire/Wire.h"
#include "dawn_wire/Wire.h"
namespace dawn { namespace wire {
namespace utils {
class TerribleCommandBuffer : public CommandSerializer {
class TerribleCommandBuffer : public dawn_wire::CommandSerializer {
public:
TerribleCommandBuffer();
TerribleCommandBuffer(CommandHandler* handler);
TerribleCommandBuffer(dawn_wire::CommandHandler* handler);
void SetHandler(CommandHandler* handler);
void SetHandler(dawn_wire::CommandHandler* handler);
void* GetCmdSpace(size_t size) override;
bool Flush() override;
private:
CommandHandler* mHandler = nullptr;
dawn_wire::CommandHandler* mHandler = nullptr;
size_t mOffset = 0;
char mBuffer[10000000];
};
}} // namespace dawn::wire
} // namespace utils
#endif // WIRE_TERRIBLE_COMMAND_BUFFER_H_
#endif // UTILS_TERRIBLE_COMMAND_BUFFER_H_

4
third_party/CMakeLists.txt vendored
View File

@ -40,6 +40,10 @@ set(GLAD_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/glad/include)
set(GLAD_INCLUDE_DIR ${GLAD_INCLUDE_DIR} PARENT_SCOPE)
target_include_directories(glad SYSTEM PUBLIC ${GLAD_INCLUDE_DIR})
DawnExternalTarget("third_party" glad)
if(APPLE)
# Workaround https://github.com/Dav1dde/glad/issues/158
set_property(TARGET glad APPEND PROPERTY COMPILE_OPTIONS "-fno-common")
endif()
# ShaderC
# Prevent SPIRV-Tools from using Werror as it has a warning on MSVC