diff options
Diffstat (limited to 'src/gallium/state_trackers')
| -rw-r--r-- | src/gallium/state_trackers/d3d1x/gd3d11/d3d11_context.h | 774 |
1 files changed, 387 insertions, 387 deletions
diff --git a/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_context.h b/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_context.h index c2b3bf45703..d7c1c921b71 100644 --- a/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_context.h +++ b/src/gallium/state_trackers/d3d1x/gd3d11/d3d11_context.h @@ -304,10 +304,10 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> #if API >= 11 #define SET_SHADER_EXTRA_ARGS , \ ID3D11ClassInstance *const *ppClassInstances, \ - unsigned NumClassInstances + unsigned count #define GET_SHADER_EXTRA_ARGS , \ ID3D11ClassInstance **ppClassInstances, \ - unsigned *pNumClassInstances + unsigned *out_count #else #define SET_SHADER_EXTRA_ARGS #define GET_SHADER_EXTRA_ARGS @@ -410,55 +410,55 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> *ppShader = (ID3D11##Stage##Shader*)shaders[D3D11_STAGE_##XS].ref(); \ } \ virtual void STDMETHODCALLTYPE XS##SetConstantBuffers(\ - unsigned StartSlot, \ - unsigned NumBuffers, \ - ID3D11Buffer *const *ppConstantBuffers) \ + unsigned start, \ + unsigned count, \ + ID3D11Buffer *const* constant_buffers) \ { \ SYNCHRONIZED; \ - xs_set_constant_buffers<D3D11_STAGE_##XS>(StartSlot, NumBuffers, (GalliumD3D11Buffer *const *)ppConstantBuffers); \ + xs_set_constant_buffers<D3D11_STAGE_##XS>(start, count, (GalliumD3D11Buffer *const *)constant_buffers); \ } \ virtual void STDMETHODCALLTYPE XS##GetConstantBuffers(\ - unsigned StartSlot, \ - unsigned NumBuffers, \ - ID3D11Buffer **ppConstantBuffers) \ + unsigned start, \ + unsigned count, \ + ID3D11Buffer **out_constant_buffers) \ { \ SYNCHRONIZED; \ - for(unsigned i = 0; i < NumBuffers; ++i) \ - ppConstantBuffers[i] = constant_buffers[D3D11_STAGE_##XS][StartSlot + i].ref(); \ + for(unsigned i = 0; i < count; ++i) \ + out_constant_buffers[i] = constant_buffers[D3D11_STAGE_##XS][start + i].ref(); \ } \ virtual void STDMETHODCALLTYPE XS##SetShaderResources(\ - unsigned StartSlot, \ - unsigned NumViews, \ - ID3D11ShaderResourceView *const *ppShaderResourceViews) \ + unsigned start, \ + unsigned count, \ + ID3D11ShaderResourceView *const *new_shader_resource_views) \ { \ SYNCHRONIZED; \ - xs_set_shader_resources<D3D11_STAGE_##XS>(StartSlot, NumViews, (GalliumD3D11ShaderResourceView *const *)ppShaderResourceViews); \ + xs_set_shader_resources<D3D11_STAGE_##XS>(start, count, (GalliumD3D11ShaderResourceView *const *)new_shader_resource_views); \ } \ virtual void STDMETHODCALLTYPE XS##GetShaderResources(\ - unsigned StartSlot, \ - unsigned NumViews, \ - ID3D11ShaderResourceView **ppShaderResourceViews) \ + unsigned start, \ + unsigned count, \ + ID3D11ShaderResourceView **out_shader_resource_views) \ { \ SYNCHRONIZED; \ - for(unsigned i = 0; i < NumViews; ++i) \ - ppShaderResourceViews[i] = shader_resource_views[D3D11_STAGE_##XS][StartSlot + i].ref(); \ + for(unsigned i = 0; i < count; ++i) \ + out_shader_resource_views[i] = shader_resource_views[D3D11_STAGE_##XS][start + i].ref(); \ } \ virtual void STDMETHODCALLTYPE XS##SetSamplers(\ - unsigned StartSlot, \ - unsigned NumSamplers, \ - ID3D11SamplerState *const *ppSamplers) \ + unsigned start, \ + unsigned count, \ + ID3D11SamplerState *const *new_samplers) \ { \ SYNCHRONIZED; \ - xs_set_samplers<D3D11_STAGE_##XS>(StartSlot, NumSamplers, (GalliumD3D11SamplerState *const *)ppSamplers); \ + xs_set_samplers<D3D11_STAGE_##XS>(start, count, (GalliumD3D11SamplerState *const *)new_samplers); \ } \ virtual void STDMETHODCALLTYPE XS##GetSamplers( \ - unsigned StartSlot, \ - unsigned NumSamplers, \ - ID3D11SamplerState **ppSamplers) \ + unsigned start, \ + unsigned count, \ + ID3D11SamplerState **out_samplers) \ { \ SYNCHRONIZED; \ - for(unsigned i = 0; i < NumSamplers; ++i) \ - ppSamplers[i] = samplers[D3D11_STAGE_##XS][StartSlot + i].ref(); \ + for(unsigned i = 0; i < count; ++i) \ + out_samplers[i] = samplers[D3D11_STAGE_##XS][start + i].ref(); \ } #define DO_VS(x) x @@ -477,24 +477,24 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> IMPLEMENT_SHADER_STAGE(CS, Compute) virtual void STDMETHODCALLTYPE CSSetUnorderedAccessViews( - unsigned StartSlot, - unsigned NumUAVs, - ID3D11UnorderedAccessView *const *ppUnorderedAccessViews, - const unsigned *pUAVInitialCounts) + unsigned start, + unsigned count, + ID3D11UnorderedAccessView *const *new_unordered_access_views, + const unsigned *new_uav_initial_counts) { SYNCHRONIZED; - for(unsigned i = 0; i < NumUAVs; ++i) - cs_unordered_access_views[StartSlot + i] = ppUnorderedAccessViews[i]; + for(unsigned i = 0; i < count; ++i) + cs_unordered_access_views[start + i] = new_unordered_access_views[i]; } virtual void STDMETHODCALLTYPE CSGetUnorderedAccessViews( - unsigned StartSlot, - unsigned NumUAVs, - ID3D11UnorderedAccessView **ppUnorderedAccessViews) + unsigned start, + unsigned count, + ID3D11UnorderedAccessView **out_unordered_access_views) { SYNCHRONIZED; - for(unsigned i = 0; i < NumUAVs; ++i) - ppUnorderedAccessViews[i] = cs_unordered_access_views[StartSlot + i].ref(); + for(unsigned i = 0; i < count; ++i) + out_unordered_access_views[i] = cs_unordered_access_views[start + i].ref(); } #endif @@ -579,79 +579,79 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> } virtual void STDMETHODCALLTYPE IASetInputLayout( - ID3D11InputLayout *pInputLayout) + ID3D11InputLayout *new_input_layout) { SYNCHRONIZED; - if(pInputLayout != input_layout.p) + if(new_input_layout != input_layout.p) { - input_layout = pInputLayout; - pipe->bind_vertex_elements_state(pipe, pInputLayout ? ((GalliumD3D11InputLayout*)pInputLayout)->object : default_input_layout); + input_layout = new_input_layout; + pipe->bind_vertex_elements_state(pipe, new_input_layout ? ((GalliumD3D11InputLayout*)new_input_layout)->object : default_input_layout); } } virtual void STDMETHODCALLTYPE IAGetInputLayout( - ID3D11InputLayout **ppInputLayout) + ID3D11InputLayout **out_input_layout) { SYNCHRONIZED; - *ppInputLayout = input_layout.ref(); + *out_input_layout = input_layout.ref(); } virtual void STDMETHODCALLTYPE IASetVertexBuffers( - unsigned StartSlot, - unsigned NumBuffers, - ID3D11Buffer *const *ppVertexBuffers, - const unsigned *pStrides, - const unsigned *pOffsets) + unsigned start, + unsigned count, + ID3D11Buffer *const *new_vertex_buffers, + const unsigned *new_strides, + const unsigned *new_offsets) { SYNCHRONIZED; int last_different = -1; - for(unsigned i = 0; i < NumBuffers; ++i) + for(unsigned i = 0; i < count; ++i) { - ID3D11Buffer* buffer = ppVertexBuffers[i]; - if(buffer != input_buffers[StartSlot + i].p - || vertex_buffers[StartSlot + i].buffer_offset != pOffsets[i] - || vertex_buffers[StartSlot + i].stride != pOffsets[i] + ID3D11Buffer* buffer = new_vertex_buffers[i]; + if(buffer != input_buffers[start + i].p + || vertex_buffers[start + i].buffer_offset != new_offsets[i] + || vertex_buffers[start + i].stride != new_offsets[i] ) { - input_buffers[StartSlot + i] = buffer; - vertex_buffers[StartSlot + i].buffer = buffer ? ((GalliumD3D11Buffer*)buffer)->resource : 0; - vertex_buffers[StartSlot + i].buffer_offset = pOffsets[i]; - vertex_buffers[StartSlot + i].stride = pStrides[i]; - vertex_buffers[StartSlot + i].max_index = ~0; + input_buffers[start + i] = buffer; + vertex_buffers[start + i].buffer = buffer ? ((GalliumD3D11Buffer*)buffer)->resource : 0; + vertex_buffers[start + i].buffer_offset = new_offsets[i]; + vertex_buffers[start + i].stride = new_strides[i]; + vertex_buffers[start + i].max_index = ~0; last_different = i; } } if(last_different >= 0) { - num_vertex_buffers = std::max(num_vertex_buffers, StartSlot + NumBuffers); + num_vertex_buffers = std::max(num_vertex_buffers, start + count); update_flags |= UPDATE_VERTEX_BUFFERS; } } virtual void STDMETHODCALLTYPE IAGetVertexBuffers( - unsigned StartSlot, - unsigned NumBuffers, - ID3D11Buffer **ppVertexBuffers, - unsigned *pStrides, - unsigned *pOffsets) + unsigned start, + unsigned count, + ID3D11Buffer **out_vertex_buffers, + unsigned *out_strides, + unsigned *out_offsets) { SYNCHRONIZED; - if(ppVertexBuffers) + if(out_vertex_buffers) { - for(unsigned i = 0; i < NumBuffers; ++i) - ppVertexBuffers[i] = input_buffers[StartSlot + i].ref(); + for(unsigned i = 0; i < count; ++i) + out_vertex_buffers[i] = input_buffers[start + i].ref(); } - if(pOffsets) + if(out_offsets) { - for(unsigned i = 0; i < NumBuffers; ++i) - pOffsets[i] = vertex_buffers[StartSlot + i].buffer_offset; + for(unsigned i = 0; i < count; ++i) + out_offsets[i] = vertex_buffers[start + i].buffer_offset; } - if(pStrides) + if(out_strides) { - for(unsigned i = 0; i < NumBuffers; ++i) - pStrides[i] = vertex_buffers[StartSlot + i].stride; + for(unsigned i = 0; i < count; ++i) + out_strides[i] = vertex_buffers[start + i].stride; } } @@ -677,60 +677,60 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> } virtual void STDMETHODCALLTYPE IASetIndexBuffer( - ID3D11Buffer *pIndexBuffer, - DXGI_FORMAT Format, - unsigned Offset) + ID3D11Buffer *new_index_buffer, + DXGI_FORMAT new_index_format, + unsigned new_index_offset) { SYNCHRONIZED; - if(index_buffer.p != pIndexBuffer || index_format != Format || index_offset != Offset) + if(index_buffer.p != new_index_buffer || index_format != new_index_format || index_offset != new_index_offset) { - index_buffer = pIndexBuffer; - index_format = Format; - index_offset = Offset; + index_buffer = new_index_buffer; + index_format = new_index_format; + index_offset = new_index_offset; set_index_buffer(); } } virtual void STDMETHODCALLTYPE IAGetIndexBuffer( - ID3D11Buffer **pIndexBuffer, - DXGI_FORMAT *Format, - unsigned *Offset) + ID3D11Buffer **out_index_buffer, + DXGI_FORMAT *out_index_format, + unsigned *out_index_offset) { SYNCHRONIZED; - if(pIndexBuffer) - *pIndexBuffer = index_buffer.ref(); - if(Format) - *Format = index_format; - if(Offset) - *Offset = index_offset; + if(out_index_buffer) + *out_index_buffer = index_buffer.ref(); + if(out_index_format) + *out_index_format = index_format; + if(out_index_offset) + *out_index_offset = index_offset; } virtual void STDMETHODCALLTYPE IASetPrimitiveTopology( - D3D11_PRIMITIVE_TOPOLOGY Topology) + D3D11_PRIMITIVE_TOPOLOGY new_primitive_topology) { SYNCHRONIZED; - if(primitive_topology != Topology) + if(primitive_topology != new_primitive_topology) { - if(Topology < D3D_PRIMITIVE_TOPOLOGY_COUNT) - primitive_mode = d3d_to_pipe_prim[Topology]; + if(new_primitive_topology < D3D_PRIMITIVE_TOPOLOGY_COUNT) + primitive_mode = d3d_to_pipe_prim[new_primitive_topology]; else primitive_mode = 0; - primitive_topology = Topology; + primitive_topology = new_primitive_topology; } } virtual void STDMETHODCALLTYPE IAGetPrimitiveTopology( - D3D11_PRIMITIVE_TOPOLOGY *pTopology) + D3D11_PRIMITIVE_TOPOLOGY *out_primitive_topology) { SYNCHRONIZED; - *pTopology = primitive_topology; + *out_primitive_topology = primitive_topology; } virtual void STDMETHODCALLTYPE DrawIndexed( - unsigned IndexCount, - unsigned StartIndexLocation, - int BaseVertexLocation) + unsigned index_count, + unsigned start_index_location, + int base_vertex_location) { SYNCHRONIZED; if(update_flags) @@ -739,9 +739,9 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> pipe_draw_info info; info.mode = primitive_mode; info.indexed = TRUE; - info.count = IndexCount; - info.start = StartIndexLocation; - info.index_bias = BaseVertexLocation; + info.count = index_count; + info.start = start_index_location; + info.index_bias = base_vertex_location; info.min_index = 0; info.max_index = ~0; info.start_instance = 0; @@ -751,8 +751,8 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> } virtual void STDMETHODCALLTYPE Draw( - unsigned VertexCount, - unsigned StartVertexLocation) + unsigned vertex_count, + unsigned start_vertex_location) { SYNCHRONIZED; if(update_flags) @@ -761,8 +761,8 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> pipe_draw_info info; info.mode = primitive_mode; info.indexed = FALSE; - info.count = VertexCount; - info.start = StartVertexLocation; + info.count = vertex_count; + info.start = start_vertex_location; info.index_bias = 0; info.min_index = 0; info.max_index = ~0; @@ -773,11 +773,11 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> } virtual void STDMETHODCALLTYPE DrawIndexedInstanced( - unsigned IndexCountPerInstance, - unsigned InstanceCount, - unsigned StartIndexLocation, - int BaseVertexLocation, - unsigned StartInstanceLocation) + unsigned index_countPerInstance, + unsigned instance_count, + unsigned start_index_location, + int base_vertex_location, + unsigned start_instance_location) { SYNCHRONIZED; if(update_flags) @@ -786,22 +786,22 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> pipe_draw_info info; info.mode = primitive_mode; info.indexed = TRUE; - info.count = IndexCountPerInstance; - info.start = StartIndexLocation; - info.index_bias = BaseVertexLocation; + info.count = index_countPerInstance; + info.start = start_index_location; + info.index_bias = base_vertex_location; info.min_index = 0; info.max_index = ~0; - info.start_instance = StartInstanceLocation; - info.instance_count = InstanceCount; + info.start_instance = start_instance_location; + info.instance_count = instance_count; pipe->draw_vbo(pipe, &info); } virtual void STDMETHODCALLTYPE DrawInstanced( - unsigned VertexCountPerInstance, - unsigned InstanceCount, - unsigned StartVertexLocation, - unsigned StartInstanceLocation) + unsigned vertex_countPerInstance, + unsigned instance_count, + unsigned start_vertex_location, + unsigned start_instance_location) { SYNCHRONIZED; if(update_flags) @@ -810,13 +810,13 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> pipe_draw_info info; info.mode = primitive_mode; info.indexed = FALSE; - info.count = VertexCountPerInstance; - info.start = StartVertexLocation; + info.count = vertex_countPerInstance; + info.start = start_vertex_location; info.index_bias = 0; info.min_index = 0; info.max_index = ~0; - info.start_instance = StartInstanceLocation; - info.instance_count = InstanceCount; + info.start_instance = start_instance_location; + info.instance_count = instance_count; pipe->draw_vbo(pipe, &info); } @@ -834,8 +834,8 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> } virtual void STDMETHODCALLTYPE DrawIndexedInstancedIndirect( - ID3D11Buffer *pBufferForArgs, - unsigned AlignedByteOffsetForArgs) + ID3D11Buffer *buffer, + unsigned aligned_byte_offset) { SYNCHRONIZED; if(update_flags) @@ -848,7 +848,7 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> unsigned index_bias; } data; - pipe_buffer_read(pipe, ((GalliumD3D11Buffer*)pBufferForArgs)->resource, AlignedByteOffsetForArgs, sizeof(data), &data); + pipe_buffer_read(pipe, ((GalliumD3D11Buffer*)buffer)->resource, aligned_byte_offset, sizeof(data), &data); pipe_draw_info info; info.mode = primitive_mode; @@ -865,8 +865,8 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> } virtual void STDMETHODCALLTYPE DrawInstancedIndirect( - ID3D11Buffer *pBufferForArgs, - unsigned AlignedByteOffsetForArgs) + ID3D11Buffer *buffer, + unsigned aligned_byte_offset) { SYNCHRONIZED; if(update_flags) @@ -878,7 +878,7 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> unsigned start; } data; - pipe_buffer_read(pipe, ((GalliumD3D11Buffer*)pBufferForArgs)->resource, AlignedByteOffsetForArgs, sizeof(data), &data); + pipe_buffer_read(pipe, ((GalliumD3D11Buffer*)buffer)->resource, aligned_byte_offset, sizeof(data), &data); pipe_draw_info info; info.mode = primitive_mode; @@ -896,9 +896,9 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> #if API >= 11 virtual void STDMETHODCALLTYPE Dispatch( - unsigned ThreadGroupCountX, - unsigned ThreadGroupCountY, - unsigned ThreadGroupCountZ) + unsigned thread_group_count_x, + unsigned thread_group_count_y, + unsigned thread_group_count_z) { // uncomment this when this is implemented // SYNCHRONIZED; @@ -907,8 +907,8 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> } virtual void STDMETHODCALLTYPE DispatchIndirect( - ID3D11Buffer *pBufferForArgs, - unsigned AlignedByteOffsetForArgs) + ID3D11Buffer *buffer, + unsigned aligned_byte_offset) { // uncomment this when this is implemented // SYNCHRONIZED; @@ -926,14 +926,14 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> } virtual void STDMETHODCALLTYPE RSSetState( - ID3D11RasterizerState *pRasterizerState) + ID3D11RasterizerState *new_rasterizer_state) { SYNCHRONIZED; - if(pRasterizerState != rasterizer_state.p) + if(new_rasterizer_state != rasterizer_state.p) { - rasterizer_state = pRasterizerState; - pipe->bind_rasterizer_state(pipe, pRasterizerState ? ((GalliumD3D11RasterizerState*)pRasterizerState)->object : default_rasterizer); - bool new_depth_clamp = pRasterizerState ? ((GalliumD3D11RasterizerState*)pRasterizerState)->depth_clamp : false; + rasterizer_state = new_rasterizer_state; + pipe->bind_rasterizer_state(pipe, new_rasterizer_state ? ((GalliumD3D11RasterizerState*)new_rasterizer_state)->object : default_rasterizer); + bool new_depth_clamp = new_rasterizer_state ? ((GalliumD3D11RasterizerState*)new_rasterizer_state)->depth_clamp : false; if(depth_clamp != new_depth_clamp) { depth_clamp = new_depth_clamp; @@ -943,10 +943,10 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> } virtual void STDMETHODCALLTYPE RSGetState( - ID3D11RasterizerState **ppRasterizerState) + ID3D11RasterizerState **out_rasterizer_state) { SYNCHRONIZED; - *ppRasterizerState = rasterizer_state.ref(); + *out_rasterizer_state = rasterizer_state.ref(); } void set_viewport() @@ -968,19 +968,19 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> } virtual void STDMETHODCALLTYPE RSSetViewports( - unsigned NumViewports, - const D3D11_VIEWPORT *pViewports) + unsigned count, + const D3D11_VIEWPORT *new_viewports) { SYNCHRONIZED; - if(NumViewports) + if(count) { - if(memcmp(&viewports[0], &pViewports[0], sizeof(viewports[0]))) + if(memcmp(&viewports[0], &new_viewports[0], sizeof(viewports[0]))) { - viewports[0] = pViewports[0]; + viewports[0] = new_viewports[0]; set_viewport(); } - for(unsigned i = 1; i < NumViewports; ++i) - viewports[i] = pViewports[i]; + for(unsigned i = 1; i < count; ++i) + viewports[i] = new_viewports[i]; } else if(num_viewports) { @@ -988,24 +988,24 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> memset(&viewports[0], 0, sizeof(viewports[0])); set_viewport(); } - num_viewports = NumViewports; + num_viewports = count; } virtual void STDMETHODCALLTYPE RSGetViewports( - unsigned *pNumViewports, - D3D11_VIEWPORT *pViewports) + unsigned *out_count, + D3D11_VIEWPORT *out_viewports) { SYNCHRONIZED; - if(pViewports) + if(out_viewports) { unsigned i; - for(i = 0; i < std::min(*pNumViewports, num_viewports); ++i) - pViewports[i] = viewports[i]; + for(i = 0; i < std::min(*out_count, num_viewports); ++i) + out_viewports[i] = viewports[i]; - memset(pViewports + i, 0, (*pNumViewports - i) * sizeof(D3D11_VIEWPORT)); + memset(out_viewports + i, 0, (*out_count - i) * sizeof(D3D11_VIEWPORT)); } - *pNumViewports = num_viewports; + *out_count = num_viewports; } void set_scissor() @@ -1019,19 +1019,19 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> } virtual void STDMETHODCALLTYPE RSSetScissorRects( - unsigned NumRects, - const D3D11_RECT *pRects) + unsigned count, + const D3D11_RECT *new_rects) { SYNCHRONIZED; - if(NumRects) + if(count) { - if(memcmp(&scissor_rects[0], &pRects[0], sizeof(scissor_rects[0]))) + if(memcmp(&scissor_rects[0], &new_rects[0], sizeof(scissor_rects[0]))) { - scissor_rects[0] = pRects[0]; + scissor_rects[0] = new_rects[0]; set_scissor(); } - for(unsigned i = 1; i < NumRects; ++i) - scissor_rects[i] = pRects[i]; + for(unsigned i = 1; i < count; ++i) + scissor_rects[i] = new_rects[i]; } else if(num_scissor_rects) { @@ -1040,69 +1040,69 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> set_scissor(); } - num_scissor_rects = NumRects; + num_scissor_rects = count; } virtual void STDMETHODCALLTYPE RSGetScissorRects( - unsigned *pNumRects, - D3D11_RECT *pRects) + unsigned *out_count, + D3D11_RECT *out_rects) { SYNCHRONIZED; - if(pRects) + if(out_rects) { unsigned i; - for(i = 0; i < std::min(*pNumRects, num_scissor_rects); ++i) - pRects[i] = scissor_rects[i]; + for(i = 0; i < std::min(*out_count, num_scissor_rects); ++i) + out_rects[i] = scissor_rects[i]; - memset(pRects + i, 0, (*pNumRects - i) * sizeof(D3D11_RECT)); + memset(out_rects + i, 0, (*out_count - i) * sizeof(D3D11_RECT)); } - *pNumRects = num_scissor_rects; + *out_count = num_scissor_rects; } virtual void STDMETHODCALLTYPE OMSetBlendState( - ID3D11BlendState *pBlendState, - const float BlendFactor[ 4 ], - unsigned SampleMask) + ID3D11BlendState *new_blend_state, + const float new_blend_factor[4], + unsigned new_sample_mask) { SYNCHRONIZED; float white[4] = {1.0f, 1.0f, 1.0f, 1.0f}; - if(blend_state.p != pBlendState) + if(blend_state.p != new_blend_state) { - pipe->bind_blend_state(pipe, pBlendState ? ((GalliumD3D11BlendState*)pBlendState)->object : default_blend); - blend_state = pBlendState; + pipe->bind_blend_state(pipe, new_blend_state ? ((GalliumD3D11BlendState*)new_blend_state)->object : default_blend); + blend_state = new_blend_state; } // Windows D3D11 does this, even though it's apparently undocumented - if(!BlendFactor) - BlendFactor = white; + if(!new_blend_factor) + new_blend_factor = white; - if(memcmp(blend_color, BlendFactor, sizeof(blend_color))) + if(memcmp(blend_color, new_blend_factor, sizeof(blend_color))) { - pipe->set_blend_color(pipe, (struct pipe_blend_color*)BlendFactor); - memcpy(blend_color, BlendFactor, sizeof(blend_color)); + pipe->set_blend_color(pipe, (struct pipe_blend_color*)new_blend_factor); + memcpy(blend_color, new_blend_factor, sizeof(blend_color)); } - if(sample_mask != SampleMask) + if(sample_mask != new_sample_mask) { - pipe->set_sample_mask(pipe, sample_mask); - sample_mask = SampleMask; + pipe->set_sample_mask(pipe, new_sample_mask); + sample_mask = new_sample_mask; } } virtual void STDMETHODCALLTYPE OMGetBlendState( - ID3D11BlendState **ppBlendState, - float BlendFactor[ 4 ], - unsigned *pSampleMask) + ID3D11BlendState **out_blend_state, + float out_blend_factor[4], + unsigned *out_sample_mask) { SYNCHRONIZED; - if(ppBlendState) - *ppBlendState = blend_state.ref(); - if(BlendFactor) - memcpy(BlendFactor, blend_color, sizeof(blend_color)); - if(pSampleMask) - *pSampleMask = sample_mask; + if(out_blend_state) + *out_blend_state = blend_state.ref(); + if(out_blend_factor) + memcpy(out_blend_factor, blend_color, sizeof(blend_color)); + if(out_sample_mask) + *out_sample_mask = sample_mask; } void set_stencil_ref() @@ -1114,32 +1114,32 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> } virtual void STDMETHODCALLTYPE OMSetDepthStencilState( - ID3D11DepthStencilState *pDepthStencilState, - unsigned StencilRef) + ID3D11DepthStencilState *new_depth_stencil_state, + unsigned new_stencil_ref) { SYNCHRONIZED; - if(pDepthStencilState != depth_stencil_state.p) + if(new_depth_stencil_state != depth_stencil_state.p) { - pipe->bind_depth_stencil_alpha_state(pipe, pDepthStencilState ? ((GalliumD3D11DepthStencilState*)pDepthStencilState)->object : default_depth_stencil); - depth_stencil_state = pDepthStencilState; + pipe->bind_depth_stencil_alpha_state(pipe, new_depth_stencil_state ? ((GalliumD3D11DepthStencilState*)new_depth_stencil_state)->object : default_depth_stencil); + depth_stencil_state = new_depth_stencil_state; } - if(StencilRef != stencil_ref) + if(new_stencil_ref != stencil_ref) { - stencil_ref = StencilRef; + stencil_ref = new_stencil_ref; set_stencil_ref(); } } virtual void STDMETHODCALLTYPE OMGetDepthStencilState( - ID3D11DepthStencilState **ppDepthStencilState, - unsigned *pStencilRef) + ID3D11DepthStencilState **out_depth_stencil_state, + unsigned *out_stencil_ref) { SYNCHRONIZED; - if(*ppDepthStencilState) - *ppDepthStencilState = depth_stencil_state.ref(); - if(pStencilRef) - *pStencilRef = stencil_ref; + if(*out_depth_stencil_state) + *out_depth_stencil_state = depth_stencil_state.ref(); + if(out_stencil_ref) + *out_stencil_ref = stencil_ref; } void set_framebuffer() @@ -1178,121 +1178,121 @@ struct GalliumD3D10Device : public GalliumD3D10ScreenImpl<threadsafe> */ virtual void STDMETHODCALLTYPE OMSetRenderTargets( - unsigned NumViews, - ID3D11RenderTargetView *const *ppRenderTargetViews, - ID3D11DepthStencilView *pDepthStencilView) + unsigned count, + ID3D11RenderTargetView *const *new_render_target_views, + ID3D11DepthStencilView *new_depth_stencil_view) { SYNCHRONIZED; - if(!ppRenderTargetViews) - NumViews = 0; - if(NumViews == num_render_target_views) + if(!new_render_target_views) + count = 0; + if(count == num_render_target_views) { - for(unsigned i = 0; i < NumViews; ++i) + for(unsigned i = 0; i < count; ++i) { - if(ppRenderTargetViews[i] != render_target_views[i].p) + if(new_render_target_views[i] != render_target_views[i].p) goto changed; } return; } changed: - depth_stencil_view = pDepthStencilView; + depth_stencil_view = new_depth_stencil_view; unsigned i; - for(i = 0; i < NumViews; ++i) + for(i = 0; i < count; ++i) { - render_target_views[i] = ppRenderTargetViews[i]; + render_target_views[i] = new_render_target_views[i]; #if API >= 11 om_unordered_access_views[i] = (ID3D11UnorderedAccessView*)NULL; #endif } for(; i < num_render_target_views; ++i) render_target_views[i] = (ID3D11RenderTargetView*)NULL; - num_render_target_views = NumViews; + num_render_target_views = count; set_framebuffer(); } virtual void STDMETHODCALLTYPE OMGetRenderTargets( - unsigned NumViews, - ID3D11RenderTargetView **ppRenderTargetViews, - ID3D11DepthStencilView **ppDepthStencilView) + unsigned count, + ID3D11RenderTargetView **out_render_target_views, + ID3D11DepthStencilView **out_depth_stencil_view) { SYNCHRONIZED; - if(ppRenderTargetViews) + if(out_render_target_views) { unsigned i; - for(i = 0; i < std::min(num_render_target_views, NumViews); ++i) - ppRenderTargetViews[i] = render_target_views[i].ref(); + for(i = 0; i < std::min(num_render_target_views, count); ++i) + out_render_target_views[i] = render_target_views[i].ref(); - for(; i < NumViews; ++i) - ppRenderTargetViews[i] = 0; + for(; i < count; ++i) + out_render_target_views[i] = 0; } - if(ppDepthStencilView) - *ppDepthStencilView = depth_stencil_view.ref(); + if(out_depth_stencil_view) + *out_depth_stencil_view = depth_stencil_view.ref(); } #if API >= 11 /* TODO: what is this supposed to do _exactly_? are we doing the right thing? */ virtual void STDMETHODCALLTYPE OMSetRenderTargetsAndUnorderedAccessViews( - unsigned NumRTVs, - ID3D11RenderTargetView *const *ppRenderTargetViews, - ID3D11DepthStencilView *pDepthStencilView, - unsigned UAVStartSlot, - unsigned NumUAVs, - ID3D11UnorderedAccessView *const *ppUnorderedAccessViews, - const unsigned *pUAVInitialCounts) + unsigned rtv_count, + ID3D11RenderTargetView *const *new_render_target_views, + ID3D11DepthStencilView *new_depth_stencil_view, + unsigned uav_start, + unsigned uav_count, + ID3D11UnorderedAccessView *const *new_unordered_access_views, + const unsigned *new_uav_initial_counts) { SYNCHRONIZED; - if(NumRTVs != D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL) - OMSetRenderTargets(NumRTVs, ppRenderTargetViews, pDepthStencilView); + if(rtv_count != D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL) + OMSetRenderTargets(rtv_count, new_render_target_views, new_depth_stencil_view); - if(NumUAVs != D3D11_KEEP_UNORDERED_ACCESS_VIEWS) + if(uav_count != D3D11_KEEP_UNORDERED_ACCESS_VIEWS) { - for(unsigned i = 0; i < NumUAVs; ++i) + for(unsigned i = 0; i < uav_count; ++i) { - om_unordered_access_views[UAVStartSlot + i] = ppUnorderedAccessViews[i]; - render_target_views[UAVStartSlot + i] = (ID3D11RenderTargetView*)0; + om_unordered_access_views[uav_start + i] = new_unordered_access_views[i]; + render_target_views[uav_start + i] = (ID3D11RenderTargetView*)0; } } } virtual void STDMETHODCALLTYPE OMGetRenderTargetsAndUnorderedAccessViews( - unsigned NumRTVs, - ID3D11RenderTargetView **ppRenderTargetViews, - ID3D11DepthStencilView **ppDepthStencilView, - unsigned UAVStartSlot, - unsigned NumUAVs, - ID3D11UnorderedAccessView **ppUnorderedAccessViews) + unsigned rtv_count, + ID3D11RenderTargetView **out_render_target_views, + ID3D11DepthStencilView **out_depth_stencil_view, + unsigned uav_start, + unsigned uav_count, + ID3D11UnorderedAccessView **out_unordered_access_views) { SYNCHRONIZED; - if(ppRenderTargetViews) - OMGetRenderTargets(NumRTVs, ppRenderTargetViews, ppDepthStencilView); + if(out_render_target_views) + OMGetRenderTargets(rtv_count, out_render_target_views, out_depth_stencil_view); - if(ppUnorderedAccessViews) + if(out_unordered_access_views) { - for(unsigned i = 0; i < NumUAVs; ++i) - ppUnorderedAccessViews[i] = om_unordered_access_views[UAVStartSlot + i].ref(); + for(unsigned i = 0; i < uav_count; ++i) + out_unordered_access_views[i] = om_unordered_access_views[uav_start + i].ref(); } } #endif virtual void STDMETHODCALLTYPE SOSetTargets( - unsigned NumBuffers, - ID3D11Buffer *const *ppSOTargets, - const unsigned *pOffsets) + unsigned count, + ID3D11Buffer *const *new_so_targets, + const unsigned *new_offsets) { SYNCHRONIZED; unsigned i; - if(!ppSOTargets) - NumBuffers = 0; + if(!new_so_targets) + count = 0; bool changed = false; - for(i = 0; i < NumBuffers; ++i) + for(i = 0; i < count; ++i) { - ID3D11Buffer* buffer = ppSOTargets[i]; - if(buffer != so_targets[i].p || pOffsets[i] != so_offsets[i]) + ID3D11Buffer* buffer = new_so_targets[i]; + if(buffer != so_targets[i].p || new_offsets[i] != so_offsets[i]) { so_buffers[i] = buffer ? ((GalliumD3D11Buffer*)buffer)->resource : 0; so_targets[i] = buffer; - so_offsets[i] = pOffsets[i]; + so_offsets[i] = new_offsets[i]; changed = true; } } @@ -1305,61 +1305,61 @@ changed: so_offsets[i] = 0; } } - num_so_targets = NumBuffers; + num_so_targets = count; if(changed && caps.so) pipe->set_stream_output_buffers(pipe, so_buffers, (int*)so_offsets, num_so_targets); } virtual void STDMETHODCALLTYPE SOGetTargets( - unsigned NumBuffers, - ID3D11Buffer **ppSOTargets + unsigned count, + ID3D11Buffer **out_so_targets #if API < 11 - , UINT *pOffsets + , UINT *out_offsets #endif ) { SYNCHRONIZED; - for(unsigned i = 0; i < NumBuffers; ++i) + for(unsigned i = 0; i < count; ++i) { - ppSOTargets[i] = so_targets[i].ref(); + out_so_targets[i] = so_targets[i].ref(); #if API < 11 - pOffsets[i] = so_offsets[i]; + out_offsets[i] = so_offsets[i]; #endif } } virtual void STDMETHODCALLTYPE Begin( - ID3D11Asynchronous *pAsync) + ID3D11Asynchronous *async) { SYNCHRONIZED; if(caps.queries) - pipe->begin_query(pipe, ((GalliumD3D11Asynchronous<>*)pAsync)->query); + pipe->begin_query(pipe, ((GalliumD3D11Asynchronous<>*)async)->query); } virtual void STDMETHODCALLTYPE End( - ID3D11Asynchronous *pAsync) + ID3D11Asynchronous *async) { SYNCHRONIZED; if(caps.queries) - pipe->end_query(pipe, ((GalliumD3D11Asynchronous<>*)pAsync)->query); + pipe->end_query(pipe, ((GalliumD3D11Asynchronous<>*)async)->query); } virtual HRESULT STDMETHODCALLTYPE GetData( - ID3D11Asynchronous *pAsync, - void *pData, - unsigned DataSize, - unsigned GetDataFlags) + ID3D11Asynchronous *iasync, + void *out_data, + unsigned data_size, + unsigned get_data_flags) { SYNCHRONIZED; if(!caps.queries) return E_NOTIMPL; - GalliumD3D11Asynchronous<>* async = (GalliumD3D11Asynchronous<>*)pAsync; - void* data = alloca(async->data_size); - boolean ret = pipe->get_query_result(pipe, ((GalliumD3D11Asynchronous<>*)pAsync)->query, !(GetDataFlags & D3D11_ASYNC_GETDATA_DONOTFLUSH), data); - if(pData) - memcpy(pData, data, std::min(async->data_size, DataSize)); + GalliumD3D11Asynchronous<>* async = (GalliumD3D11Asynchronous<>*)iasync; + void* tmp_data = alloca(async->data_size); + boolean ret = pipe->get_query_result(pipe, async->query, !(get_data_flags & D3D11_ASYNC_GETDATA_DONOTFLUSH), tmp_data); + if(out_data) + memcpy(out_data, tmp_data, std::min(async->data_size, data_size)); return ret ? S_OK : S_FALSE; } @@ -1387,27 +1387,27 @@ changed: } virtual void STDMETHODCALLTYPE SetPredication( - ID3D11Predicate *pPredicate, - BOOL PredicateValue) + ID3D11Predicate *new_predicate, + BOOL new_predicate_value) { SYNCHRONIZED; - if(render_predicate.p != pPredicate || render_predicate_value != PredicateValue) + if(render_predicate.p != new_predicate || render_predicate_value != new_predicate_value) { - render_predicate = pPredicate; - render_predicate_value = PredicateValue; + render_predicate = new_predicate; + render_predicate_value = new_predicate_value; set_render_condition(); } } virtual void STDMETHODCALLTYPE GetPredication( - ID3D11Predicate **ppPredicate, - BOOL *pPredicateValue) + ID3D11Predicate **out_predicate, + BOOL *out_predicate_value) { SYNCHRONIZED; - if(ppPredicate) - *ppPredicate = render_predicate.ref(); - if(pPredicateValue) - *pPredicateValue = render_predicate_value; + if(out_predicate) + *out_predicate = render_predicate.ref(); + if(out_predicate_value) + *out_predicate_value = render_predicate_value; } static pipe_subresource d3d11_to_pipe_subresource(struct pipe_resource* resource, unsigned subresource) @@ -1428,56 +1428,56 @@ changed: } virtual HRESULT STDMETHODCALLTYPE Map( - ID3D11Resource *pResource, - unsigned Subresource, - D3D11_MAP MapType, - unsigned MapFlags, - D3D11_MAPPED_SUBRESOURCE *pMappedResource) + ID3D11Resource *iresource, + unsigned subresource, + D3D11_MAP map_type, + unsigned map_flags, + D3D11_MAPPED_SUBRESOURCE *mapped_resource) { SYNCHRONIZED; - GalliumD3D11Resource<>* resource = (GalliumD3D11Resource<>*)pResource; - if(resource->transfers.count(Subresource)) + GalliumD3D11Resource<>* resource = (GalliumD3D11Resource<>*)iresource; + if(resource->transfers.count(subresource)) return E_FAIL; - pipe_subresource sr = d3d11_to_pipe_subresource(resource->resource, Subresource); + pipe_subresource sr = d3d11_to_pipe_subresource(resource->resource, subresource); pipe_box box; d3d11_to_pipe_box(resource->resource, sr.level, 0); unsigned usage = 0; - if(MapType == D3D11_MAP_READ) + if(map_type == D3D11_MAP_READ) usage = PIPE_TRANSFER_READ; - else if(MapType == D3D11_MAP_WRITE) + else if(map_type == D3D11_MAP_WRITE) usage = PIPE_TRANSFER_WRITE; - else if(MapType == D3D11_MAP_READ_WRITE) + else if(map_type == D3D11_MAP_READ_WRITE) usage = PIPE_TRANSFER_READ_WRITE; - else if(MapType == D3D11_MAP_WRITE_DISCARD) + else if(map_type == D3D11_MAP_WRITE_DISCARD) usage = PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD; - else if(MapType == D3D11_MAP_WRITE_NO_OVERWRITE) + else if(map_type == D3D11_MAP_WRITE_NO_OVERWRITE) usage = PIPE_TRANSFER_WRITE | PIPE_TRANSFER_NOOVERWRITE; else return E_INVALIDARG; - if(MapType & D3D10_MAP_FLAG_DO_NOT_WAIT) + if(map_type & D3D10_MAP_FLAG_DO_NOT_WAIT) usage |= PIPE_TRANSFER_DONTBLOCK; struct pipe_transfer* transfer = pipe->get_transfer(pipe, resource->resource, sr, usage, &box); if(!transfer) { - if(MapType & D3D10_MAP_FLAG_DO_NOT_WAIT) + if(map_type & D3D10_MAP_FLAG_DO_NOT_WAIT) return DXGI_ERROR_WAS_STILL_DRAWING; else return E_FAIL; } - resource->transfers[Subresource] = transfer; + resource->transfers[subresource] = transfer; pipe->transfer_map(pipe, transfer); - pMappedResource->pData = transfer->data; - pMappedResource->RowPitch = transfer->stride; - pMappedResource->DepthPitch = transfer->slice_stride; + mapped_resource->pData = transfer->data; + mapped_resource->RowPitch = transfer->stride; + mapped_resource->DepthPitch = transfer->slice_stride; return S_OK; } virtual void STDMETHODCALLTYPE Unmap( - ID3D11Resource *pResource, - unsigned Subresource) + ID3D11Resource *iresource, + unsigned subresource) { SYNCHRONIZED; - GalliumD3D11Resource<>* resource = (GalliumD3D11Resource<>*)pResource; - std::unordered_map<unsigned, pipe_transfer*>::iterator i = resource->transfers.find(Subresource); + GalliumD3D11Resource<>* resource = (GalliumD3D11Resource<>*)iresource; + std::unordered_map<unsigned, pipe_transfer*>::iterator i = resource->transfers.find(subresource); if(i != resource->transfers.end()) { pipe->transfer_unmap(pipe, i->second); @@ -1487,37 +1487,37 @@ changed: } virtual void STDMETHODCALLTYPE CopySubresourceRegion( - ID3D11Resource *pDstResource, - unsigned DstSubresource, - unsigned DstX, - unsigned DstY, - unsigned DstZ, - ID3D11Resource *pSrcResource, - unsigned SrcSubresource, - const D3D11_BOX *pSrcBox) + ID3D11Resource *dst_resource, + unsigned dst_subresource, + unsigned dst_x, + unsigned dst_y, + unsigned dst_z, + ID3D11Resource *src_resource, + unsigned src_subresource, + const D3D11_BOX *src_box) { SYNCHRONIZED; - GalliumD3D11Resource<>* dst = (GalliumD3D11Resource<>*)pDstResource; - GalliumD3D11Resource<>* src = (GalliumD3D11Resource<>*)pSrcResource; - pipe_subresource subdst = d3d11_to_pipe_subresource(dst->resource, DstSubresource); - pipe_subresource subsrc = d3d11_to_pipe_subresource(src->resource, SrcSubresource); - pipe_box box = d3d11_to_pipe_box(src->resource, subsrc.level, pSrcBox); + GalliumD3D11Resource<>* dst = (GalliumD3D11Resource<>*)dst_resource; + GalliumD3D11Resource<>* src = (GalliumD3D11Resource<>*)src_resource; + pipe_subresource subdst = d3d11_to_pipe_subresource(dst->resource, dst_subresource); + pipe_subresource subsrc = d3d11_to_pipe_subresource(src->resource, src_subresource); + pipe_box box = d3d11_to_pipe_box(src->resource, subsrc.level, src_box); for(unsigned i = 0; i < box.depth; ++i) { pipe->resource_copy_region(pipe, - dst->resource, subdst, DstX, DstY, DstZ + i, + dst->resource, subdst, dst_x, dst_y, dst_z + i, src->resource, subsrc, box.x, box.y, box.z + i, box.width, box.height); } } virtual void STDMETHODCALLTYPE CopyResource( - ID3D11Resource *pDstResource, - ID3D11Resource *pSrcResource) + ID3D11Resource *dst_resource, + ID3D11Resource *src_resource) { SYNCHRONIZED; - GalliumD3D11Resource<>* dst = (GalliumD3D11Resource<>*)pDstResource; - GalliumD3D11Resource<>* src = (GalliumD3D11Resource<>*)pSrcResource; + GalliumD3D11Resource<>* dst = (GalliumD3D11Resource<>*)dst_resource; + GalliumD3D11Resource<>* src = (GalliumD3D11Resource<>*)src_resource; pipe_subresource sr; unsigned faces = dst->resource->target == PIPE_TEXTURE_CUBE ? 6 : 1; @@ -1540,66 +1540,66 @@ changed: } virtual void STDMETHODCALLTYPE UpdateSubresource( - ID3D11Resource *pDstResource, - unsigned DstSubresource, + ID3D11Resource *dst_resource, + unsigned dst_subresource, const D3D11_BOX *pDstBox, const void *pSrcData, - unsigned SrcRowPitch, - unsigned SrcDepthPitch) + unsigned src_row_pitch, + unsigned src_depth_pitch) { SYNCHRONIZED; - GalliumD3D11Resource<>* dst = (GalliumD3D11Resource<>*)pDstResource; - pipe_subresource subdst = d3d11_to_pipe_subresource(dst->resource, DstSubresource); + GalliumD3D11Resource<>* dst = (GalliumD3D11Resource<>*)dst_resource; + pipe_subresource subdst = d3d11_to_pipe_subresource(dst->resource, dst_subresource); pipe_box box = d3d11_to_pipe_box(dst->resource, subdst.level, pDstBox); - pipe->transfer_inline_write(pipe, dst->resource, subdst, PIPE_TRANSFER_WRITE, &box, pSrcData, SrcRowPitch, SrcDepthPitch); + pipe->transfer_inline_write(pipe, dst->resource, subdst, PIPE_TRANSFER_WRITE, &box, pSrcData, src_row_pitch, src_depth_pitch); } #if API >= 11 virtual void STDMETHODCALLTYPE CopyStructureCount( - ID3D11Buffer *pDstBuffer, - unsigned DstAlignedByteOffset, - ID3D11UnorderedAccessView *pSrcView) + ID3D11Buffer *dst_buffer, + unsigned dst_aligned_byte_offset, + ID3D11UnorderedAccessView *src_view) { SYNCHRONIZED; } #endif virtual void STDMETHODCALLTYPE ClearRenderTargetView( - ID3D11RenderTargetView *pRenderTargetView, - const float ColorRGBA[4]) + ID3D11RenderTargetView *render_target_view, + const float color[4]) { SYNCHRONIZED; - GalliumD3D11RenderTargetView* view = ((GalliumD3D11RenderTargetView*)pRenderTargetView); - pipe->clear_render_target(pipe, view->object, ColorRGBA, 0, 0, view->object->width, view->object->height); + GalliumD3D11RenderTargetView* view = ((GalliumD3D11RenderTargetView*)render_target_view); + pipe->clear_render_target(pipe, view->object, color, 0, 0, view->object->width, view->object->height); } virtual void STDMETHODCALLTYPE ClearDepthStencilView( - ID3D11DepthStencilView *pDepthStencilView, - unsigned ClearFlags, - float Depth, - UINT8 Stencil) + ID3D11DepthStencilView *depth_stencil_view, + unsigned clear_flags, + float depth, + UINT8 stencil) { SYNCHRONIZED; - GalliumD3D11DepthStencilView* view = ((GalliumD3D11DepthStencilView*)pDepthStencilView); + GalliumD3D11DepthStencilView* view = ((GalliumD3D11DepthStencilView*)depth_stencil_view); unsigned flags = 0; - if(ClearFlags & D3D11_CLEAR_DEPTH) + if(clear_flags & D3D11_CLEAR_DEPTH) flags |= PIPE_CLEAR_DEPTH; - if(ClearFlags & D3D11_CLEAR_STENCIL) + if(clear_flags & D3D11_CLEAR_STENCIL) flags |= PIPE_CLEAR_STENCIL; - pipe->clear_depth_stencil(pipe, view->object, flags, Depth, Stencil, 0, 0, view->object->width, view->object->height); + pipe->clear_depth_stencil(pipe, view->object, flags, depth, stencil, 0, 0, view->object->width, view->object->height); } #if API >= 11 virtual void STDMETHODCALLTYPE ClearUnorderedAccessViewUint( - ID3D11UnorderedAccessView *pUnorderedAccessView, - const unsigned Values[ 4 ]) + ID3D11UnorderedAccessView *unordered_access_view, + const unsigned values[4]) { SYNCHRONIZED; } virtual void STDMETHODCALLTYPE ClearUnorderedAccessViewFloat( - ID3D11UnorderedAccessView *pUnorderedAccessView, - const float Values[ 4 ]) + ID3D11UnorderedAccessView *unordered_access_view, + const float values[4]) { SYNCHRONIZED; } @@ -1631,11 +1631,11 @@ changed: } virtual void STDMETHODCALLTYPE GenerateMips( - ID3D11ShaderResourceView *pShaderResourceView) + ID3D11ShaderResourceView *shader_resource_view) { SYNCHRONIZED; - GalliumD3D11ShaderResourceView* view = (GalliumD3D11ShaderResourceView*)pShaderResourceView; + GalliumD3D11ShaderResourceView* view = (GalliumD3D11ShaderResourceView*)shader_resource_view; if(caps.gs) pipe->bind_gs_state(pipe, 0); if(caps.so) @@ -1675,53 +1675,53 @@ changed: #if API >= 11 /* TODO: hack SRVs or sampler states to handle this, or add to Gallium */ virtual void STDMETHODCALLTYPE SetResourceMinLOD( - ID3D11Resource *pResource, - float MinLOD) + ID3D11Resource *iresource, + float min_lod) { SYNCHRONIZED; - GalliumD3D11Resource<>* resource = (GalliumD3D11Resource<>*)pResource; - if(resource->min_lod != MinLOD) + GalliumD3D11Resource<>* resource = (GalliumD3D11Resource<>*)iresource; + if(resource->min_lod != min_lod) { // TODO: actually do anything? - resource->min_lod = MinLOD; + resource->min_lod = min_lod; } } virtual float STDMETHODCALLTYPE GetResourceMinLOD( - ID3D11Resource *pResource) + ID3D11Resource *iresource) { SYNCHRONIZED; - GalliumD3D11Resource<>* resource = (GalliumD3D11Resource<>*)pResource; + GalliumD3D11Resource<>* resource = (GalliumD3D11Resource<>*)iresource; return resource->min_lod; } #endif virtual void STDMETHODCALLTYPE ResolveSubresource( - ID3D11Resource *pDstResource, - unsigned DstSubresource, - ID3D11Resource *pSrcResource, - unsigned SrcSubresource, - DXGI_FORMAT Format) + ID3D11Resource *dst_resource, + unsigned dst_subresource, + ID3D11Resource *src_resource, + unsigned src_subresource, + DXGI_FORMAT format) { SYNCHRONIZED; - GalliumD3D11Resource<>* dst = (GalliumD3D11Resource<>*)pDstResource; - GalliumD3D11Resource<>* src = (GalliumD3D11Resource<>*)pSrcResource; - pipe_subresource subdst = d3d11_to_pipe_subresource(dst->resource, DstSubresource); - pipe_subresource subsrc = d3d11_to_pipe_subresource(src->resource, SrcSubresource); + GalliumD3D11Resource<>* dst = (GalliumD3D11Resource<>*)dst_resource; + GalliumD3D11Resource<>* src = (GalliumD3D11Resource<>*)src_resource; + pipe_subresource subdst = d3d11_to_pipe_subresource(dst->resource, dst_subresource); + pipe_subresource subsrc = d3d11_to_pipe_subresource(src->resource, src_subresource); pipe->resource_resolve(pipe, dst->resource, subdst, src->resource, subsrc); } #if API >= 11 virtual void STDMETHODCALLTYPE ExecuteCommandList( - ID3D11CommandList *pCommandList, - BOOL RestoreContextState) + ID3D11CommandList *command_list, + BOOL restore_context_state) { SYNCHRONIZED; } virtual HRESULT STDMETHODCALLTYPE FinishCommandList( - BOOL RestoreDeferredContextState, - ID3D11CommandList **ppCommandList) + BOOL restore_deferred_context_state, + ID3D11CommandList **out_command_list) { SYNCHRONIZED; return E_NOTIMPL; @@ -1898,7 +1898,7 @@ changed: } } - void UnbindDepthStencilView(ID3D11DepthStencilView* view) + void UnbindDepthStencilView(ID3D11DepthStencilView * view) { SYNCHRONIZED; if(view == depth_stencil_view) |