Skip to content
This repository has been archived by the owner on Mar 17, 2019. It is now read-only.

Commit

Permalink
GL and D3D backends separated
Browse files Browse the repository at this point in the history
  • Loading branch information
@bazhenovc
bazhenovc committed Mar 15, 2015
1 parent 826c9e0 commit 8d1a8de
Show file tree
Hide file tree
Showing 2 changed files with 55 additions and 55 deletions.
40 changes: 20 additions & 20 deletions CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -29,31 +29,31 @@ source_group("demo\\common\\include" FILES ${demo_common_hdr})
source_group("demo\\source" FILES ${demo_src})
source_group("demo\\include" FILES ${demo_hdr})

set(SGFX_GLEW_SRC
sigrlinn/GL/glew.c
sigrlinn/GL/glew.h
sigrlinn/GL/glxew.h
sigrlinn/GL/wglew.h
)

include_directories(${CMAKE_SOURCE_DIR}/sigrlinn)
include_directories(${CMAKE_SOURCE_DIR}/external/glm/)
add_library(Sigrlinn STATIC
${demo_common_src}
${demo_common_hdr}
${src}
${hdr}
${src_internal}
${hdr_internal}

# GLEW
sigrlinn/GL/glew.c
sigrlinn/GL/glew.h
sigrlinn/GL/glxew.h
sigrlinn/GL/wglew.h
)

add_executable(GrassDemo WIN32 demo/demo_grass.cc demo/win32_app.cc)
target_link_libraries(GrassDemo Sigrlinn)
add_library(SigrlinnD3D11 ${hdr} ${hdr_internal} ${src_internal} sigrlinn/sigrlinn_d3d11.cc)
add_library(SigrlinnGL4 ${hdr} ${hdr_internal} ${src_internal} ${SGFX_GLEW_SRC} sigrlinn/sigrlinn_gl4.cc)

function(AddDemo Name Source)

add_executable(${Name}D3D11 WIN32 ${Source} ${demo_common_src} ${demo_common_hdr} demo/win32_app.cc)
target_link_libraries(${Name}D3D11 SigrlinnD3D11)

add_executable(Cube WIN32 demo/demo_cube.cc demo/win32_app.cc)
target_link_libraries(Cube Sigrlinn)
#add_executable(${Name}GL4 ${Source} ${demo_common_src} ${demo_common_hdr} demo/win32_app.cc)
#target_link_libraries(${Name}GL4 SigrlinnGL4)
endfunction()

add_executable(PBR WIN32 demo/demo_pbr.cc demo/win32_app.cc)
target_link_libraries(PBR Sigrlinn)
AddDemo(GrassDemo demo/demo_grass.cc)
AddDemo(CubeDemo demo/demo_cube.cc)
AddDemo(PBR demo/demo_pbr.cc)

#add_executable(NBody WIN32 demo/demo_nbody.cc demo/win32_app.cc)
#target_link_libraries(NBody Sigrlinn)
70 changes: 35 additions & 35 deletions sigrlinn/sigrlinn_gl4.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -510,7 +510,7 @@ static void GL_processDrawQueue(internal::DrawQueue* queue)
}

//-------------------------------------------------------------------------------------------------
bool compileShader_GL(
bool compileShader(
const char* sourceCode,
size_t sourceCodeSize,
ShaderCompileVersion version,
Expand All @@ -527,7 +527,7 @@ bool compileShader_GL(
return false;
}

VertexFormatHandle createVertexFormat_GL(
VertexFormatHandle createVertexFormat(
VertexElementDescriptor* elements,
size_t size,
void* shaderBytecode, size_t shaderBytecodeSize,
Expand All @@ -553,30 +553,30 @@ VertexFormatHandle createVertexFormat_GL(
return VertexFormatHandle(impl);
}

void releaseVertexFormat_GL(VertexFormatHandle handle)
void releaseVertexFormat(VertexFormatHandle handle)
{
if (handle != VertexFormatHandle::invalidHandle()) {
GLVertexFormatImpl* impl = static_cast<GLVertexFormatImpl*>(handle.value);
delete impl;
}
}

PipelineStateHandle createPipelineState_GL(const PipelineStateDescriptor& desc)
PipelineStateHandle createPipelineState(const PipelineStateDescriptor& desc)
{
PipelineStateDescriptor* ret = new PipelineStateDescriptor;
std::memcpy(ret, &desc, sizeof(PipelineStateDescriptor));
return PipelineStateHandle(ret);
}

void releasePipelineState_GL(PipelineStateHandle handle)
void releasePipelineState(PipelineStateHandle handle)
{
if (handle != PipelineStateHandle::invalidHandle()) {
PipelineStateDescriptor* desc = static_cast<PipelineStateDescriptor*>(handle.value);
delete desc;
}
}

BufferHandle createBuffer_GL(uint32_t flags, const void* mem, size_t size, size_t stride)
BufferHandle createBuffer(uint32_t flags, const void* mem, size_t size, size_t stride)
{
GLBufferImpl* impl = new GLBufferImpl;

Expand Down Expand Up @@ -636,15 +636,15 @@ BufferHandle createBuffer_GL(uint32_t flags, const void* mem, size_t size, size_
return BufferHandle(impl);
}

void releaseBuffer_GL(BufferHandle handle)
void releaseBuffer(BufferHandle handle)
{
if (handle != BufferHandle::invalidHandle()) {
GLBufferImpl* impl = static_cast<GLBufferImpl*>(handle.value);
delete impl;
}
}

void* mapBuffer_GL(BufferHandle handle, MapType type)
void* mapBuffer(BufferHandle handle, MapType type)
{
if (handle != BufferHandle::invalidHandle()) {
GLBufferImpl* impl = static_cast<GLBufferImpl*>(handle.value);
Expand All @@ -655,7 +655,7 @@ void* mapBuffer_GL(BufferHandle handle, MapType type)
return nullptr;
}

void unmapBuffer_GL(BufferHandle handle)
void unmapBuffer(BufferHandle handle)
{
if (handle != BufferHandle::invalidHandle()) {
GLBufferImpl* impl = static_cast<GLBufferImpl*>(handle.value);
Expand All @@ -664,7 +664,7 @@ void unmapBuffer_GL(BufferHandle handle)
}
}

void copyBufferData_GL(BufferHandle handle, size_t offset, size_t size, const void* mem)
void copyBufferData(BufferHandle handle, size_t offset, size_t size, const void* mem)
{
if (handle != BufferHandle::invalidHandle()) {
GLBufferImpl* impl = static_cast<GLBufferImpl*>(handle.value);
Expand All @@ -673,7 +673,7 @@ void copyBufferData_GL(BufferHandle handle, size_t offset, size_t size, const vo
}
}

ConstantBufferHandle createConstantBuffer_GL(const void* mem, size_t size)
ConstantBufferHandle createConstantBuffer(const void* mem, size_t size)
{
GLBufferImpl* impl = new GLBufferImpl;

Expand All @@ -687,7 +687,7 @@ ConstantBufferHandle createConstantBuffer_GL(const void* mem, size_t size)
return ConstantBufferHandle(impl);
}

void updateConstantBuffer_GL(ConstantBufferHandle handle, const void* mem)
void updateConstantBuffer(ConstantBufferHandle handle, const void* mem)
{
if (handle != ConstantBufferHandle::invalidHandle()) {
GLBufferImpl* impl = static_cast<GLBufferImpl*>(handle.value);
Expand All @@ -696,15 +696,15 @@ void updateConstantBuffer_GL(ConstantBufferHandle handle, const void* mem)
}
}

void releaseConstantBuffer_GL(ConstantBufferHandle handle)
void releaseConstantBuffer(ConstantBufferHandle handle)
{
if (handle != ConstantBufferHandle::invalidHandle()) {
GLBufferImpl* impl = static_cast<GLBufferImpl*>(handle.value);
delete impl;
}
}

SamplerStateHandle createSamplerState_GL(const SamplerStateDescriptor& desc)
SamplerStateHandle createSamplerState(const SamplerStateDescriptor& desc)
{
GLSamplerStateImpl* impl = new GLSamplerStateImpl;

Expand Down Expand Up @@ -734,15 +734,15 @@ SamplerStateHandle createSamplerState_GL(const SamplerStateDescriptor& desc)
return SamplerStateHandle(impl);
}

void releaseSamplerState_GL(SamplerStateHandle handle)
void releaseSamplerState(SamplerStateHandle handle)
{
if (handle != SamplerStateHandle::invalidHandle()) {
GLSamplerStateImpl* impl = static_cast<GLSamplerStateImpl*>(handle.value);
delete impl;
}
}

Texture1DHandle createTexture1D_GL(uint32_t width, DataFormat format, uint32_t numMipmaps, uint32_t flags)
Texture1DHandle createTexture1D(uint32_t width, DataFormat format, uint32_t numMipmaps, uint32_t flags)
{
GLTextureImpl* impl = new GLTextureImpl;
impl->numDimensions = 1;
Expand All @@ -760,7 +760,7 @@ Texture1DHandle createTexture1D_GL(uint32_t width, DataFormat format, uint32_t n
return Texture1DHandle(impl);
}

Texture2DHandle createTexture2D_GL(uint32_t width, uint32_t height, DataFormat format, uint32_t numMipmaps, uint32_t flags)
Texture2DHandle createTexture2D(uint32_t width, uint32_t height, DataFormat format, uint32_t numMipmaps, uint32_t flags)
{
GLTextureImpl* impl = new GLTextureImpl;
impl->numDimensions = 2;
Expand All @@ -779,7 +779,7 @@ Texture2DHandle createTexture2D_GL(uint32_t width, uint32_t height, DataFormat f
return Texture2DHandle(impl);
}

Texture3DHandle createTexture3D_GL(uint32_t width, uint32_t height, uint32_t depth, DataFormat format, uint32_t numMipmaps, uint32_t flags)
Texture3DHandle createTexture3D(uint32_t width, uint32_t height, uint32_t depth, DataFormat format, uint32_t numMipmaps, uint32_t flags)
{
GLTextureImpl* impl = new GLTextureImpl;
impl->numDimensions = 3;
Expand All @@ -799,7 +799,7 @@ Texture3DHandle createTexture3D_GL(uint32_t width, uint32_t height, uint32_t dep
return Texture3DHandle(impl);
}

void updateTexture_GL(
void updateTexture(
TextureHandle handle, const void* mem,
uint32_t mip,
size_t offsetX, size_t sizeX,
Expand Down Expand Up @@ -844,7 +844,7 @@ void updateTexture_GL(
}
}

void releaseTexture_GL(TextureHandle handle)
void releaseTexture(TextureHandle handle)
{
if (handle != TextureHandle::invalidHandle()) {
GLTextureImpl* impl = static_cast<GLTextureImpl*>(handle.value);
Expand All @@ -854,117 +854,117 @@ void releaseTexture_GL(TextureHandle handle)

// draw queue stuff is similar for all APIs

DrawQueueHandle createDrawQueue_GL(PipelineStateHandle state)
DrawQueueHandle createDrawQueue(PipelineStateHandle state)
{
internal::DrawQueue* queue = new internal::DrawQueue(state);
return DrawQueueHandle(queue);
}

void releaseDrawQueue_GL(DrawQueueHandle handle)
void releaseDrawQueue(DrawQueueHandle handle)
{
if (handle != DrawQueueHandle::invalidHandle()) {
internal::DrawQueue* queue = static_cast<internal::DrawQueue*>(handle.value);
delete queue;
}
}

void setSamplerState_GL(DrawQueueHandle handle, uint32_t idx, SamplerStateHandle sampler)
void setSamplerState(DrawQueueHandle handle, uint32_t idx, SamplerStateHandle sampler)
{
if (handle != DrawQueueHandle::invalidHandle()) {
internal::DrawQueue* queue = static_cast<internal::DrawQueue*>(handle.value);
queue->setSamplerState(idx, sampler);
}
}

void setPrimitiveTopology_GL(DrawQueueHandle handle, PrimitiveTopology topology)
void setPrimitiveTopology(DrawQueueHandle handle, PrimitiveTopology topology)
{
if (handle != DrawQueueHandle::invalidHandle()) {
internal::DrawQueue* queue = static_cast<internal::DrawQueue*>(handle.value);
queue->setPrimitiveTopology(topology);
}
}

void setVertexBuffer_GL(DrawQueueHandle handle, BufferHandle vb)
void setVertexBuffer(DrawQueueHandle handle, BufferHandle vb)
{
if (handle != DrawQueueHandle::invalidHandle()) {
internal::DrawQueue* queue = static_cast<internal::DrawQueue*>(handle.value);
queue->setVertexBuffer(vb);
}
}

void setIndexBuffer_GL(DrawQueueHandle handle, BufferHandle ib)
void setIndexBuffer(DrawQueueHandle handle, BufferHandle ib)
{
if (handle != DrawQueueHandle::invalidHandle()) {
internal::DrawQueue* queue = static_cast<internal::DrawQueue*>(handle.value);
queue->setIndexBuffer(ib);
}
}

void setConstantBuffer_GL(DrawQueueHandle handle, uint32_t idx, ConstantBufferHandle buffer)
void setConstantBuffer(DrawQueueHandle handle, uint32_t idx, ConstantBufferHandle buffer)
{
if (handle != DrawQueueHandle::invalidHandle()) {
internal::DrawQueue* queue = static_cast<internal::DrawQueue*>(handle.value);
queue->setConstantBuffer(idx, buffer);
}
}

void setResource_GL(DrawQueueHandle handle, uint32_t idx, BufferHandle resource)
void setResource(DrawQueueHandle handle, uint32_t idx, BufferHandle resource)
{
if (handle != DrawQueueHandle::invalidHandle()) {
internal::DrawQueue* queue = static_cast<internal::DrawQueue*>(handle.value);
queue->setResource(idx, resource);
}
}

void setResource_GL(DrawQueueHandle handle, uint32_t idx, TextureHandle resource)
void setResource(DrawQueueHandle handle, uint32_t idx, TextureHandle resource)
{
if (handle != DrawQueueHandle::invalidHandle()) {
internal::DrawQueue* queue = static_cast<internal::DrawQueue*>(handle.value);
queue->setResource(idx, resource);
}
}

void setResourceRW_GL(DrawQueueHandle handle, uint32_t idx, BufferHandle resource)
void setResourceRW(DrawQueueHandle handle, uint32_t idx, BufferHandle resource)
{
if (handle != DrawQueueHandle::invalidHandle()) {
internal::DrawQueue* queue = static_cast<internal::DrawQueue*>(handle.value);
queue->setResourceRW(idx, resource);
}
}

void draw_GL(DrawQueueHandle handle, uint32_t count, uint32_t startVertex)
void draw(DrawQueueHandle handle, uint32_t count, uint32_t startVertex)
{
if (handle != DrawQueueHandle::invalidHandle()) {
internal::DrawQueue* queue = static_cast<internal::DrawQueue*>(handle.value);
queue->draw(count, startVertex);
}
}

void drawIndexed_GL(DrawQueueHandle handle, uint32_t count, uint32_t startIndex, uint32_t startVertex)
void drawIndexed(DrawQueueHandle handle, uint32_t count, uint32_t startIndex, uint32_t startVertex)
{
if (handle != DrawQueueHandle::invalidHandle()) {
internal::DrawQueue* queue = static_cast<internal::DrawQueue*>(handle.value);
queue->drawIndexed(count, startIndex, startVertex);
}
}

void drawInstanced_GL(DrawQueueHandle handle, uint32_t instanceCount, uint32_t count, uint32_t startVertex)
void drawInstanced(DrawQueueHandle handle, uint32_t instanceCount, uint32_t count, uint32_t startVertex)
{
if (handle != DrawQueueHandle::invalidHandle()) {
internal::DrawQueue* queue = static_cast<internal::DrawQueue*>(handle.value);
queue->drawInstanced(instanceCount, count, startVertex);
}
}

void drawIndexedInstanced_GL(DrawQueueHandle handle, uint32_t instanceCount, uint32_t count, uint32_t startIndex, uint32_t startVertex)
void drawIndexedInstanced(DrawQueueHandle handle, uint32_t instanceCount, uint32_t count, uint32_t startIndex, uint32_t startVertex)
{
if (handle != DrawQueueHandle::invalidHandle()) {
internal::DrawQueue* queue = static_cast<internal::DrawQueue*>(handle.value);
queue->drawIndexedInstanced(instanceCount, count, startIndex, startVertex);
}
}

void submit_GL(DrawQueueHandle handle)
void submit(DrawQueueHandle handle)
{
if (handle != DrawQueueHandle::invalidHandle()) {
internal::DrawQueue* queue = static_cast<internal::DrawQueue*>(handle.value);
Expand Down

0 comments on commit 8d1a8de

Please sign in to comment.