KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
mesa/src/gallium/frontends/d3d10umd/Shader.cpp

1415 lines
45 KiB
C++
Raw Blame History

/**************************************************************************
*
* Copyright 2012-2021 VMware, Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
**************************************************************************/
/*
* Shader.cpp --
* Functions that manipulate shader resources.
*/
#include "Shader.h"
#include "ShaderParse.h"
#include "State.h"
#include "Query.h"
#include "Debug.h"
#include "Format.h"
#include "tgsi/tgsi_ureg.h"
#include "util/u_gen_mipmap.h"
#include "util/u_sampler.h"
#include "util/format/u_format.h"
/*
* ----------------------------------------------------------------------
*
* CreateEmptyShader --
*
* Update the driver's currently bound constant buffers.
*
* ----------------------------------------------------------------------
*/
void *
CreateEmptyShader(Device *pDevice,
enum pipe_shader_type processor)
{
struct pipe_context *pipe = pDevice->pipe;
struct ureg_program *ureg;
const struct tgsi_token *tokens;
uint nr_tokens;
if (processor == PIPE_SHADER_GEOMETRY) {
return NULL;
}
ureg = ureg_create(processor);
if (!ureg)
return NULL;
ureg_END(ureg);
tokens = ureg_get_tokens(ureg, &nr_tokens);
if (!tokens)
return NULL;
ureg_destroy(ureg);
struct pipe_shader_state state;
memset(&state, 0, sizeof state);
state.tokens = tokens;
void *handle;
switch (processor) {
case PIPE_SHADER_FRAGMENT:
handle = pipe->create_fs_state(pipe, &state);
break;
case PIPE_SHADER_VERTEX:
handle = pipe->create_vs_state(pipe, &state);
break;
case PIPE_SHADER_GEOMETRY:
handle = pipe->create_gs_state(pipe, &state);
break;
default:
handle = NULL;
assert(0);
}
assert(handle);
ureg_free_tokens(tokens);
return handle;
}
/*
* ----------------------------------------------------------------------
*
* CreateEmptyShader --
*
* Update the driver's currently bound constant buffers.
*
* ----------------------------------------------------------------------
*/
void
DeleteEmptyShader(Device *pDevice,
enum pipe_shader_type processor, void *handle)
{
struct pipe_context *pipe = pDevice->pipe;
if (processor == PIPE_SHADER_GEOMETRY) {
assert(handle == NULL);
return;
}
assert(handle != NULL);
switch (processor) {
case PIPE_SHADER_FRAGMENT:
pipe->delete_fs_state(pipe, handle);
break;
case PIPE_SHADER_VERTEX:
pipe->delete_vs_state(pipe, handle);
break;
case PIPE_SHADER_GEOMETRY:
pipe->delete_gs_state(pipe, handle);
break;
default:
assert(0);
}
}
/*
* ----------------------------------------------------------------------
*
* SetConstantBuffers --
*
* Update the driver's currently bound constant buffers.
*
* ----------------------------------------------------------------------
*/
static void
SetConstantBuffers(enum pipe_shader_type shader_type, // IN
D3D10DDI_HDEVICE hDevice, // IN
UINT StartBuffer, // IN
UINT NumBuffers, // IN
const D3D10DDI_HRESOURCE *phBuffers) // IN
{
Device *pDevice = CastDevice(hDevice);
struct pipe_context *pipe = pDevice->pipe;
for (UINT i = 0; i < NumBuffers; i++) {
struct pipe_constant_buffer cb;
memset(&cb, 0, sizeof cb);
cb.buffer = CastPipeResource(phBuffers[i]);
cb.buffer_offset = 0;
cb.buffer_size = cb.buffer ? cb.buffer->width0 : 0;
pipe->set_constant_buffer(pipe,
shader_type,
StartBuffer + i,
FALSE,
&cb);
}
}
/*
* ----------------------------------------------------------------------
*
* SetSamplers --
*
* Update the driver's currently bound sampler state.
*
* ----------------------------------------------------------------------
*/
static void
SetSamplers(enum pipe_shader_type shader_type, // IN
D3D10DDI_HDEVICE hDevice, // IN
UINT Offset, // IN
UINT NumSamplers, // IN
const D3D10DDI_HSAMPLER *phSamplers) // IN
{
Device *pDevice = CastDevice(hDevice);
struct pipe_context *pipe = pDevice->pipe;
void **samplers = pDevice->samplers[shader_type];
for (UINT i = 0; i < NumSamplers; i++) {
assert(Offset + i < PIPE_MAX_SAMPLERS);
samplers[Offset + i] = CastPipeSamplerState(phSamplers[i]);
}
pipe->bind_sampler_states(pipe, shader_type, 0, PIPE_MAX_SAMPLERS, samplers);
}
/*
* ----------------------------------------------------------------------
*
* SetSamplers --
*
* Update the driver's currently bound sampler state.
*
* ----------------------------------------------------------------------
*/
static void
SetShaderResources(enum pipe_shader_type shader_type, // IN
D3D10DDI_HDEVICE hDevice, // IN
UINT Offset, // IN
UINT NumViews, // IN
const D3D10DDI_HSHADERRESOURCEVIEW *phShaderResourceViews) // IN
{
Device *pDevice = CastDevice(hDevice);
struct pipe_context *pipe = pDevice->pipe;
assert(Offset + NumViews <= D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT);
struct pipe_sampler_view **sampler_views = pDevice->sampler_views[shader_type];
for (UINT i = 0; i < NumViews; i++) {
struct pipe_sampler_view *sampler_view =
CastPipeShaderResourceView(phShaderResourceViews[i]);
if (Offset + i < PIPE_MAX_SHADER_SAMPLER_VIEWS) {
sampler_views[Offset + i] = sampler_view;
} else {
if (sampler_view) {
LOG_UNSUPPORTED(TRUE);
break;
}
}
}
/*
* XXX: Now that the semantics are actually the same in gallium, should
* probably think about not updating all always... It should just work.
*/
pipe->set_sampler_views(pipe, shader_type, 0, PIPE_MAX_SHADER_SAMPLER_VIEWS,
0, sampler_views);
}
/*
* ----------------------------------------------------------------------
*
* CalcPrivateShaderSize --
*
* The CalcPrivateShaderSize function determines the size of
* the user-mode display driver's private region of memory
* (that is, the size of internal driver structures, not the
* size of the resource video memory) for a shader.
*
* ----------------------------------------------------------------------
*/
SIZE_T APIENTRY
CalcPrivateShaderSize(D3D10DDI_HDEVICE hDevice, // IN
__in_ecount (pShaderCode[1]) const UINT *pShaderCode, // IN
__in const D3D10DDIARG_STAGE_IO_SIGNATURES *pSignatures) // IN
{
return sizeof(Shader);
}
/*
* ----------------------------------------------------------------------
*
* DestroyShader --
*
* The DestroyShader function destroys the specified shader object.
* The shader object can be destoyed only if it is not currently
* bound to a display device.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
DestroyShader(D3D10DDI_HDEVICE hDevice, // IN
D3D10DDI_HSHADER hShader) // IN
{
LOG_ENTRYPOINT();
struct pipe_context *pipe = CastPipeContext(hDevice);
Shader *pShader = CastShader(hShader);
if (pShader->handle) {
switch (pShader->type) {
case PIPE_SHADER_FRAGMENT:
pipe->delete_fs_state(pipe, pShader->handle);
break;
case PIPE_SHADER_VERTEX:
pipe->delete_vs_state(pipe, pShader->handle);
break;
case PIPE_SHADER_GEOMETRY:
pipe->delete_gs_state(pipe, pShader->handle);
break;
default:
assert(0);
}
}
if (pShader->state.tokens) {
ureg_free_tokens(pShader->state.tokens);
}
}
/*
* ----------------------------------------------------------------------
*
* CalcPrivateSamplerSize --
*
* The CalcPrivateSamplerSize function determines the size of the
* user-mode display driver's private region of memory (that is,
* the size of internal driver structures, not the size of the
* resource video memory) for a sampler.
*
* ----------------------------------------------------------------------
*/
SIZE_T APIENTRY
CalcPrivateSamplerSize(D3D10DDI_HDEVICE hDevice, // IN
__in const D3D10_DDI_SAMPLER_DESC *pSamplerDesc) // IN
{
return sizeof(SamplerState);
}
static uint
translate_address_mode(D3D10_DDI_TEXTURE_ADDRESS_MODE AddressMode)
{
switch (AddressMode) {
case D3D10_DDI_TEXTURE_ADDRESS_WRAP:
return PIPE_TEX_WRAP_REPEAT;
case D3D10_DDI_TEXTURE_ADDRESS_MIRROR:
return PIPE_TEX_WRAP_MIRROR_REPEAT;
case D3D10_DDI_TEXTURE_ADDRESS_CLAMP:
return PIPE_TEX_WRAP_CLAMP_TO_EDGE;
case D3D10_DDI_TEXTURE_ADDRESS_BORDER:
return PIPE_TEX_WRAP_CLAMP_TO_BORDER;
case D3D10_DDI_TEXTURE_ADDRESS_MIRRORONCE:
return PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE;
default:
assert(0);
return PIPE_TEX_WRAP_REPEAT;
}
}
static uint
translate_comparison(D3D10_DDI_COMPARISON_FUNC Func)
{
switch (Func) {
case D3D10_DDI_COMPARISON_NEVER:
return PIPE_FUNC_NEVER;
case D3D10_DDI_COMPARISON_LESS:
return PIPE_FUNC_LESS;
case D3D10_DDI_COMPARISON_EQUAL:
return PIPE_FUNC_EQUAL;
case D3D10_DDI_COMPARISON_LESS_EQUAL:
return PIPE_FUNC_LEQUAL;
case D3D10_DDI_COMPARISON_GREATER:
return PIPE_FUNC_GREATER;
case D3D10_DDI_COMPARISON_NOT_EQUAL:
return PIPE_FUNC_NOTEQUAL;
case D3D10_DDI_COMPARISON_GREATER_EQUAL:
return PIPE_FUNC_GEQUAL;
case D3D10_DDI_COMPARISON_ALWAYS:
return PIPE_FUNC_ALWAYS;
default:
assert(0);
return PIPE_FUNC_ALWAYS;
}
}
static uint
translate_filter(D3D10_DDI_FILTER_TYPE Filter)
{
switch (Filter) {
case D3D10_DDI_FILTER_TYPE_POINT:
return PIPE_TEX_FILTER_NEAREST;
case D3D10_DDI_FILTER_TYPE_LINEAR:
return PIPE_TEX_FILTER_LINEAR;
default:
assert(0);
return PIPE_TEX_FILTER_NEAREST;
}
}
static uint
translate_min_filter(D3D10_DDI_FILTER Filter)
{
return translate_filter(D3D10_DDI_DECODE_MIN_FILTER(Filter));
}
static uint
translate_mag_filter(D3D10_DDI_FILTER Filter)
{
return translate_filter(D3D10_DDI_DECODE_MAG_FILTER(Filter));
}
/* Gallium uses a different enum for mipfilters, to accomodate the GL
* MIPFILTER_NONE mode.
*/
static uint
translate_mip_filter(D3D10_DDI_FILTER Filter)
{
switch (D3D10_DDI_DECODE_MIP_FILTER(Filter)) {
case D3D10_DDI_FILTER_TYPE_POINT:
return PIPE_TEX_MIPFILTER_NEAREST;
case D3D10_DDI_FILTER_TYPE_LINEAR:
return PIPE_TEX_MIPFILTER_LINEAR;
default:
assert(0);
return PIPE_TEX_MIPFILTER_NEAREST;
}
}
/*
* ----------------------------------------------------------------------
*
* CreateSampler --
*
* The CreateSampler function creates a sampler.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
CreateSampler(D3D10DDI_HDEVICE hDevice, // IN
__in const D3D10_DDI_SAMPLER_DESC *pSamplerDesc, // IN
D3D10DDI_HSAMPLER hSampler, // IN
D3D10DDI_HRTSAMPLER hRTSampler) // IN
{
LOG_ENTRYPOINT();
struct pipe_context *pipe = CastPipeContext(hDevice);
SamplerState *pSamplerState = CastSamplerState(hSampler);
struct pipe_sampler_state state;
memset(&state, 0, sizeof state);
/* d3d10 has seamless cube filtering always enabled */
state.seamless_cube_map = 1;
/* Wrapping modes. */
state.wrap_s = translate_address_mode(pSamplerDesc->AddressU);
state.wrap_t = translate_address_mode(pSamplerDesc->AddressV);
state.wrap_r = translate_address_mode(pSamplerDesc->AddressW);
/* Filtering */
state.min_img_filter = translate_min_filter(pSamplerDesc->Filter);
state.mag_img_filter = translate_mag_filter(pSamplerDesc->Filter);
state.min_mip_filter = translate_mip_filter(pSamplerDesc->Filter);
if (D3D10_DDI_DECODE_IS_ANISOTROPIC_FILTER(pSamplerDesc->Filter)) {
state.max_anisotropy = pSamplerDesc->MaxAnisotropy;
}
/* XXX: Handle the following bit.
*/
LOG_UNSUPPORTED(D3D10_DDI_DECODE_IS_TEXT_1BIT_FILTER(pSamplerDesc->Filter));
/* Comparison. */
if (D3D10_DDI_DECODE_IS_COMPARISON_FILTER(pSamplerDesc->Filter)) {
state.compare_mode = PIPE_TEX_COMPARE_R_TO_TEXTURE;
state.compare_func = translate_comparison(pSamplerDesc->ComparisonFunc);
}
state.normalized_coords = 1;
/* Level of detail. */
state.lod_bias = pSamplerDesc->MipLODBias;
state.min_lod = pSamplerDesc->MinLOD;
state.max_lod = pSamplerDesc->MaxLOD;
/* Border color. */
state.border_color.f[0] = pSamplerDesc->BorderColor[0];
state.border_color.f[1] = pSamplerDesc->BorderColor[1];
state.border_color.f[2] = pSamplerDesc->BorderColor[2];
state.border_color.f[3] = pSamplerDesc->BorderColor[3];
pSamplerState->handle = pipe->create_sampler_state(pipe, &state);
}
/*
* ----------------------------------------------------------------------
*
* DestroySampler --
*
* The DestroySampler function destroys the specified sampler object.
* The sampler object can be destoyed only if it is not currently
* bound to a display device.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
DestroySampler(D3D10DDI_HDEVICE hDevice, // IN
D3D10DDI_HSAMPLER hSampler) // IN
{
LOG_ENTRYPOINT();
struct pipe_context *pipe = CastPipeContext(hDevice);
SamplerState *pSamplerState = CastSamplerState(hSampler);
pipe->delete_sampler_state(pipe, pSamplerState->handle);
}
/*
* ----------------------------------------------------------------------
*
* CreateVertexShader --
*
* The CreateVertexShader function creates a vertex shader.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
CreateVertexShader(D3D10DDI_HDEVICE hDevice, // IN
__in_ecount (pShaderCode[1]) const UINT *pCode, // IN
D3D10DDI_HSHADER hShader, // IN
D3D10DDI_HRTSHADER hRTShader, // IN
__in const D3D10DDIARG_STAGE_IO_SIGNATURES *pSignatures) // IN
{
LOG_ENTRYPOINT();
struct pipe_context *pipe = CastPipeContext(hDevice);
Shader *pShader = CastShader(hShader);
pShader->type = PIPE_SHADER_VERTEX;
pShader->output_resolved = TRUE;
memset(&pShader->state, 0, sizeof pShader->state);
pShader->state.tokens = Shader_tgsi_translate(pCode, pShader->output_mapping);
pShader->handle = pipe->create_vs_state(pipe, &pShader->state);
}
/*
* ----------------------------------------------------------------------
*
* VsSetShader --
*
* The VsSetShader function sets the vertex shader code so that all
* of the subsequent drawing operations use that code.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
VsSetShader(D3D10DDI_HDEVICE hDevice, // IN
D3D10DDI_HSHADER hShader) // IN
{
LOG_ENTRYPOINT();
Device *pDevice = CastDevice(hDevice);
struct pipe_context *pipe = pDevice->pipe;
Shader *pShader = CastShader(hShader);
void *state = CastPipeShader(hShader);
pDevice->bound_vs = pShader;
if (!state) {
state = pDevice->empty_vs;
}
pipe->bind_vs_state(pipe, state);
}
/*
* ----------------------------------------------------------------------
*
* VsSetShaderResources --
*
* The VsSetShaderResources function sets resources for a
* vertex shader.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
VsSetShaderResources(D3D10DDI_HDEVICE hDevice, // IN
UINT Offset, // IN
UINT NumViews, // IN
__in_ecount (NumViews)
const D3D10DDI_HSHADERRESOURCEVIEW *phShaderResourceViews) // IN
{
LOG_ENTRYPOINT();
SetShaderResources(PIPE_SHADER_VERTEX, hDevice, Offset, NumViews, phShaderResourceViews);
}
/*
* ----------------------------------------------------------------------
*
* VsSetConstantBuffers --
*
* The VsSetConstantBuffers function sets constant buffers
* for a vertex shader.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
VsSetConstantBuffers(D3D10DDI_HDEVICE hDevice, // IN
UINT StartBuffer, // IN
UINT NumBuffers, // IN
__in_ecount (NumBuffers) const D3D10DDI_HRESOURCE *phBuffers) // IN
{
LOG_ENTRYPOINT();
SetConstantBuffers(PIPE_SHADER_VERTEX,
hDevice, StartBuffer, NumBuffers, phBuffers);
}
/*
* ----------------------------------------------------------------------
*
* VsSetSamplers --
*
* The VsSetSamplers function sets samplers for a vertex shader.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
VsSetSamplers(D3D10DDI_HDEVICE hDevice, // IN
UINT Offset, // IN
UINT NumSamplers, // IN
__in_ecount (NumSamplers) const D3D10DDI_HSAMPLER *phSamplers) // IN
{
LOG_ENTRYPOINT();
SetSamplers(PIPE_SHADER_VERTEX, hDevice, Offset, NumSamplers, phSamplers);
}
/*
* ----------------------------------------------------------------------
*
* CreateGeometryShader --
*
* The CreateGeometryShader function creates a geometry shader.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
CreateGeometryShader(D3D10DDI_HDEVICE hDevice, // IN
__in_ecount (pShaderCode[1]) const UINT *pShaderCode, // IN
D3D10DDI_HSHADER hShader, // IN
D3D10DDI_HRTSHADER hRTShader, // IN
__in const D3D10DDIARG_STAGE_IO_SIGNATURES *pSignatures) // IN
{
LOG_ENTRYPOINT();
struct pipe_context *pipe = CastPipeContext(hDevice);
Shader *pShader = CastShader(hShader);
pShader->type = PIPE_SHADER_GEOMETRY;
pShader->output_resolved = TRUE;
memset(&pShader->state, 0, sizeof pShader->state);
pShader->state.tokens = Shader_tgsi_translate(pShaderCode, pShader->output_mapping);
pShader->handle = pipe->create_gs_state(pipe, &pShader->state);
}
/*
* ----------------------------------------------------------------------
*
* GsSetShader --
*
* The GsSetShader function sets the geometry shader code so that
* all of the subsequent drawing operations use that code.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
GsSetShader(D3D10DDI_HDEVICE hDevice, // IN
D3D10DDI_HSHADER hShader) // IN
{
LOG_ENTRYPOINT();
Device *pDevice = CastDevice(hDevice);
struct pipe_context *pipe = CastPipeContext(hDevice);
void *state = CastPipeShader(hShader);
Shader *pShader = CastShader(hShader);
assert(pipe->bind_gs_state);
if (pShader && !pShader->state.tokens) {
pDevice->bound_empty_gs = pShader;
} else {
pDevice->bound_empty_gs = NULL;
pipe->bind_gs_state(pipe, state);
}
}
/*
* ----------------------------------------------------------------------
*
* GsSetShaderResources --
*
* The GsSetShaderResources function sets resources for a
* geometry shader.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
GsSetShaderResources(D3D10DDI_HDEVICE hDevice, // IN
UINT Offset, // IN
UINT NumViews, // IN
__in_ecount (NumViews)
const D3D10DDI_HSHADERRESOURCEVIEW *phShaderResourceViews) // IN
{
LOG_ENTRYPOINT();
SetShaderResources(PIPE_SHADER_GEOMETRY, hDevice, Offset, NumViews, phShaderResourceViews);
}
/*
* ----------------------------------------------------------------------
*
* GsSetConstantBuffers --
*
* The GsSetConstantBuffers function sets constant buffers for
* a geometry shader.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
GsSetConstantBuffers(D3D10DDI_HDEVICE hDevice, // IN
UINT StartBuffer, // IN
UINT NumBuffers, // IN
__in_ecount (NumBuffers) const D3D10DDI_HRESOURCE *phBuffers) // IN
{
LOG_ENTRYPOINT();
SetConstantBuffers(PIPE_SHADER_GEOMETRY,
hDevice, StartBuffer, NumBuffers, phBuffers);
}
/*
* ----------------------------------------------------------------------
*
* GsSetSamplers --
*
* The GsSetSamplers function sets samplers for a geometry shader.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
GsSetSamplers(D3D10DDI_HDEVICE hDevice, // IN
UINT Offset, // IN
UINT NumSamplers, // IN
__in_ecount (NumSamplers) const D3D10DDI_HSAMPLER *phSamplers) // IN
{
LOG_ENTRYPOINT();
SetSamplers(PIPE_SHADER_GEOMETRY, hDevice, Offset, NumSamplers, phSamplers);
}
/*
* ----------------------------------------------------------------------
*
* CalcPrivateGeometryShaderWithStreamOutput --
*
* The CalcPrivateGeometryShaderWithStreamOutput function determines
* the size of the user-mode display driver's private region of memory
* (that is, the size of internal driver structures, not the size of
* the resource video memory) for a geometry shader with stream output.
*
* ----------------------------------------------------------------------
*/
SIZE_T APIENTRY
CalcPrivateGeometryShaderWithStreamOutput(
D3D10DDI_HDEVICE hDevice, // IN
__in const D3D10DDIARG_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT *pCreateGeometryShaderWithStreamOutput, // IN
__in const D3D10DDIARG_STAGE_IO_SIGNATURES *pSignatures) // IN
{
LOG_ENTRYPOINT();
return sizeof(Shader);
}
/*
* ----------------------------------------------------------------------
*
* CreateGeometryShaderWithStreamOutput --
*
* The CreateGeometryShaderWithStreamOutput function creates a
* geometry shader with stream output.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
CreateGeometryShaderWithStreamOutput(
D3D10DDI_HDEVICE hDevice, // IN
__in const D3D10DDIARG_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT *pData, // IN
D3D10DDI_HSHADER hShader, // IN
D3D10DDI_HRTSHADER hRTShader, // IN
__in const D3D10DDIARG_STAGE_IO_SIGNATURES *pSignatures) // IN
{
LOG_ENTRYPOINT();
struct pipe_context *pipe = CastPipeContext(hDevice);
Shader *pShader = CastShader(hShader);
int total_components[PIPE_MAX_SO_BUFFERS] = {0};
unsigned num_holes = 0;
boolean all_slot_zero = TRUE;
pShader->type = PIPE_SHADER_GEOMETRY;
memset(&pShader->state, 0, sizeof pShader->state);
if (pData->pShaderCode) {
pShader->state.tokens = Shader_tgsi_translate(pData->pShaderCode,
pShader->output_mapping);
}
pShader->output_resolved = (pShader->state.tokens != NULL);
for (unsigned i = 0; i < pData->NumEntries; ++i) {
CONST D3D10DDIARG_STREAM_OUTPUT_DECLARATION_ENTRY* pOutputStreamDecl =
&pData->pOutputStreamDecl[i];
BYTE RegisterMask = pOutputStreamDecl->RegisterMask;
unsigned start_component = 0;
unsigned num_components = 0;
if (RegisterMask) {
while ((RegisterMask & 1) == 0) {
++start_component;
RegisterMask >>= 1;
}
while (RegisterMask) {
++num_components;
RegisterMask >>= 1;
}
assert(start_component < 4);
assert(1 <= num_components && num_components <= 4);
LOG_UNSUPPORTED(((1 << num_components) - 1) << start_component !=
pOutputStreamDecl->RegisterMask);
}
if (pOutputStreamDecl->RegisterIndex == 0xffffffff) {
++num_holes;
} else {
unsigned idx = i - num_holes;
pShader->state.stream_output.output[idx].start_component =
start_component;
pShader->state.stream_output.output[idx].num_components =
num_components;
pShader->state.stream_output.output[idx].output_buffer =
pOutputStreamDecl->OutputSlot;
pShader->state.stream_output.output[idx].register_index =
ShaderFindOutputMapping(pShader, pOutputStreamDecl->RegisterIndex);
pShader->state.stream_output.output[idx].dst_offset =
total_components[pOutputStreamDecl->OutputSlot];
if (pOutputStreamDecl->OutputSlot != 0)
all_slot_zero = FALSE;
}
total_components[pOutputStreamDecl->OutputSlot] += num_components;
}
pShader->state.stream_output.num_outputs = pData->NumEntries - num_holes;
for (unsigned i = 0; i < PIPE_MAX_SO_BUFFERS; ++i) {
/* stream_output.stride[i] is in dwords */
if (all_slot_zero) {
pShader->state.stream_output.stride[i] =
pData->StreamOutputStrideInBytes / sizeof(float);
} else {
pShader->state.stream_output.stride[i] = total_components[i];
}
}
pShader->handle = pipe->create_gs_state(pipe, &pShader->state);
}
/*
* ----------------------------------------------------------------------
*
* SoSetTargets --
*
* The SoSetTargets function sets stream output target resources.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
SoSetTargets(D3D10DDI_HDEVICE hDevice, // IN
UINT SOTargets, // IN
UINT ClearTargets, // IN
__in_ecount (SOTargets) const D3D10DDI_HRESOURCE *phResource, // IN
__in_ecount (SOTargets) const UINT *pOffsets) // IN
{
unsigned i;
LOG_ENTRYPOINT();
Device *pDevice = CastDevice(hDevice);
struct pipe_context *pipe = pDevice->pipe;
assert(SOTargets + ClearTargets <= PIPE_MAX_SO_BUFFERS);
for (i = 0; i < SOTargets; ++i) {
Resource *resource = CastResource(phResource[i]);
struct pipe_resource *buffer = CastPipeResource(phResource[i]);
struct pipe_stream_output_target *so_target =
resource ? resource->so_target : NULL;
if (buffer) {
unsigned buffer_size = buffer->width0;
if (!so_target ||
so_target->buffer != buffer ||
so_target->buffer_size != buffer_size) {
if (so_target) {
pipe_so_target_reference(&so_target, NULL);
}
so_target = pipe->create_stream_output_target(pipe, buffer,
0,/*buffer offset*/
buffer_size);
resource->so_target = so_target;
}
}
pDevice->so_targets[i] = so_target;
}
for (i = 0; i < ClearTargets; ++i) {
pDevice->so_targets[SOTargets + i] = NULL;
}
if (!pipe->set_stream_output_targets) {
LOG_UNSUPPORTED(pipe->set_stream_output_targets);
return;
}
pipe->set_stream_output_targets(pipe, SOTargets, pDevice->so_targets,
pOffsets);
}
/*
* ----------------------------------------------------------------------
*
* CreatePixelShader --
*
* The CreatePixelShader function converts pixel shader code into a
* hardware-specific format and associates this code with a
* shader handle.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
CreatePixelShader(D3D10DDI_HDEVICE hDevice, // IN
__in_ecount (pShaderCode[1]) const UINT *pShaderCode, // IN
D3D10DDI_HSHADER hShader, // IN
D3D10DDI_HRTSHADER hRTShader, // IN
__in const D3D10DDIARG_STAGE_IO_SIGNATURES *pSignatures) // IN
{
LOG_ENTRYPOINT();
struct pipe_context *pipe = CastPipeContext(hDevice);
Shader *pShader = CastShader(hShader);
pShader->type = PIPE_SHADER_FRAGMENT;
pShader->output_resolved = TRUE;
memset(&pShader->state, 0, sizeof pShader->state);
pShader->state.tokens = Shader_tgsi_translate(pShaderCode,
pShader->output_mapping);
pShader->handle = pipe->create_fs_state(pipe, &pShader->state);
}
/*
* ----------------------------------------------------------------------
*
* PsSetShader --
*
* The PsSetShader function sets a pixel shader to be used
* in all drawing operations.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
PsSetShader(D3D10DDI_HDEVICE hDevice, // IN
D3D10DDI_HSHADER hShader) // IN
{
LOG_ENTRYPOINT();
Device *pDevice = CastDevice(hDevice);
struct pipe_context *pipe = pDevice->pipe;
void *state = CastPipeShader(hShader);
if (!state) {
state = pDevice->empty_fs;
}
pipe->bind_fs_state(pipe, state);
}
/*
* ----------------------------------------------------------------------
*
* PsSetShaderResources --
*
* The PsSetShaderResources function sets resources for a pixel shader.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
PsSetShaderResources(D3D10DDI_HDEVICE hDevice, // IN
UINT Offset, // IN
UINT NumViews, // IN
__in_ecount (NumViews)
const D3D10DDI_HSHADERRESOURCEVIEW *phShaderResourceViews) // IN
{
LOG_ENTRYPOINT();
SetShaderResources(PIPE_SHADER_FRAGMENT, hDevice, Offset, NumViews, phShaderResourceViews);
}
/*
* ----------------------------------------------------------------------
*
* PsSetConstantBuffers --
*
* The PsSetConstantBuffers function sets constant buffers for
* a pixel shader.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
PsSetConstantBuffers(D3D10DDI_HDEVICE hDevice, // IN
UINT StartBuffer, // IN
UINT NumBuffers, // IN
__in_ecount (NumBuffers) const D3D10DDI_HRESOURCE *phBuffers) // IN
{
LOG_ENTRYPOINT();
SetConstantBuffers(PIPE_SHADER_FRAGMENT,
hDevice, StartBuffer, NumBuffers, phBuffers);
}
/*
* ----------------------------------------------------------------------
*
* PsSetSamplers --
*
* The PsSetSamplers function sets samplers for a pixel shader.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
PsSetSamplers(D3D10DDI_HDEVICE hDevice, // IN
UINT Offset, // IN
UINT NumSamplers, // IN
__in_ecount (NumSamplers) const D3D10DDI_HSAMPLER *phSamplers) // IN
{
LOG_ENTRYPOINT();
SetSamplers(PIPE_SHADER_FRAGMENT, hDevice, Offset, NumSamplers, phSamplers);
}
/*
* ----------------------------------------------------------------------
*
* ShaderResourceViewReadAfterWriteHazard --
*
* The ShaderResourceViewReadAfterWriteHazard function informs
* the usermode display driver that the specified resource was
* used as an output from the graphics processing unit (GPU)
* and that the resource will be used as an input to the GPU.
* A shader resource view is also provided to indicate which
* view caused the hazard.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
ShaderResourceViewReadAfterWriteHazard(D3D10DDI_HDEVICE hDevice, // IN
D3D10DDI_HSHADERRESOURCEVIEW hShaderResourceView, // IN
D3D10DDI_HRESOURCE hResource) // IN
{
LOG_ENTRYPOINT();
/* Not actually necessary */
}
/*
* ----------------------------------------------------------------------
*
* CalcPrivateShaderResourceViewSize --
*
* The CalcPrivateShaderResourceViewSize function determines the size
* of the usermode display driver's private region of memory
* (that is, the size of internal driver structures, not the size of
* the resource video memory) for a shader resource view.
*
* ----------------------------------------------------------------------
*/
SIZE_T APIENTRY
CalcPrivateShaderResourceViewSize(
D3D10DDI_HDEVICE hDevice, // IN
__in const D3D10DDIARG_CREATESHADERRESOURCEVIEW *pCreateSRView) // IN
{
return sizeof(ShaderResourceView);
}
/*
* ----------------------------------------------------------------------
*
* CalcPrivateShaderResourceViewSize --
*
* The CalcPrivateShaderResourceViewSize function determines the size
* of the usermode display driver's private region of memory
* (that is, the size of internal driver structures, not the size of
* the resource video memory) for a shader resource view.
*
* ----------------------------------------------------------------------
*/
SIZE_T APIENTRY
CalcPrivateShaderResourceViewSize1(
D3D10DDI_HDEVICE hDevice, // IN
__in const D3D10_1DDIARG_CREATESHADERRESOURCEVIEW *pCreateSRView) // IN
{
return sizeof(ShaderResourceView);
}
/*
* ----------------------------------------------------------------------
*
* CreateShaderResourceView --
*
* The CreateShaderResourceView function creates a shader
* resource view.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
CreateShaderResourceView(
D3D10DDI_HDEVICE hDevice, // IN
__in const D3D10DDIARG_CREATESHADERRESOURCEVIEW *pCreateSRView, // IN
D3D10DDI_HSHADERRESOURCEVIEW hShaderResourceView, // IN
D3D10DDI_HRTSHADERRESOURCEVIEW hRTShaderResourceView) // IN
{
LOG_ENTRYPOINT();
struct pipe_context *pipe = CastPipeContext(hDevice);
ShaderResourceView *pSRView = CastShaderResourceView(hShaderResourceView);
struct pipe_resource *resource;
enum pipe_format format;
struct pipe_sampler_view desc;
memset(&desc, 0, sizeof desc);
resource = CastPipeResource(pCreateSRView->hDrvResource);
format = FormatTranslate(pCreateSRView->Format, FALSE);
u_sampler_view_default_template(&desc,
resource,
format);
switch (pCreateSRView->ResourceDimension) {
case D3D10DDIRESOURCE_BUFFER: {
const struct util_format_description *fdesc = util_format_description(format);
desc.u.buf.offset = pCreateSRView->Buffer.FirstElement *
(fdesc->block.bits / 8) * fdesc->block.width;
desc.u.buf.size = pCreateSRView->Buffer.NumElements *
(fdesc->block.bits / 8) * fdesc->block.width;
}
break;
case D3D10DDIRESOURCE_TEXTURE1D:
desc.u.tex.first_level = pCreateSRView->Tex1D.MostDetailedMip;
desc.u.tex.last_level = pCreateSRView->Tex1D.MipLevels - 1 + desc.u.tex.first_level;
desc.u.tex.first_layer = pCreateSRView->Tex1D.FirstArraySlice;
desc.u.tex.last_layer = pCreateSRView->Tex1D.ArraySize - 1 + desc.u.tex.first_layer;
assert(pCreateSRView->Tex1D.MipLevels != 0 && pCreateSRView->Tex1D.MipLevels != (UINT)-1);
assert(pCreateSRView->Tex1D.ArraySize != 0 && pCreateSRView->Tex1D.ArraySize != (UINT)-1);
break;
case D3D10DDIRESOURCE_TEXTURE2D:
desc.u.tex.first_level = pCreateSRView->Tex2D.MostDetailedMip;
desc.u.tex.last_level = pCreateSRView->Tex2D.MipLevels - 1 + desc.u.tex.first_level;
desc.u.tex.first_layer = pCreateSRView->Tex2D.FirstArraySlice;
desc.u.tex.last_layer = pCreateSRView->Tex2D.ArraySize - 1 + desc.u.tex.first_layer;
assert(pCreateSRView->Tex2D.MipLevels != 0 && pCreateSRView->Tex2D.MipLevels != (UINT)-1);
assert(pCreateSRView->Tex2D.ArraySize != 0 && pCreateSRView->Tex2D.ArraySize != (UINT)-1);
break;
case D3D10DDIRESOURCE_TEXTURE3D:
desc.u.tex.first_level = pCreateSRView->Tex3D.MostDetailedMip;
desc.u.tex.last_level = pCreateSRView->Tex3D.MipLevels - 1 + desc.u.tex.first_level;
/* layer info filled in by default_template */
assert(pCreateSRView->Tex3D.MipLevels != 0 && pCreateSRView->Tex3D.MipLevels != (UINT)-1);
break;
case D3D10DDIRESOURCE_TEXTURECUBE:
desc.u.tex.first_level = pCreateSRView->TexCube.MostDetailedMip;
desc.u.tex.last_level = pCreateSRView->TexCube.MipLevels - 1 + desc.u.tex.first_level;
/* layer info filled in by default_template */
assert(pCreateSRView->TexCube.MipLevels != 0 && pCreateSRView->TexCube.MipLevels != (UINT)-1);
break;
default:
assert(0);
return;
}
pSRView->handle = pipe->create_sampler_view(pipe, resource, &desc);
}
/*
* ----------------------------------------------------------------------
*
* CreateShaderResourceView1 --
*
* The CreateShaderResourceView function creates a shader
* resource view.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
CreateShaderResourceView1(
D3D10DDI_HDEVICE hDevice, // IN
__in const D3D10_1DDIARG_CREATESHADERRESOURCEVIEW *pCreateSRView, // IN
D3D10DDI_HSHADERRESOURCEVIEW hShaderResourceView, // IN
D3D10DDI_HRTSHADERRESOURCEVIEW hRTShaderResourceView) // IN
{
LOG_ENTRYPOINT();
struct pipe_context *pipe = CastPipeContext(hDevice);
ShaderResourceView *pSRView = CastShaderResourceView(hShaderResourceView);
struct pipe_resource *resource;
enum pipe_format format;
struct pipe_sampler_view desc;
memset(&desc, 0, sizeof desc);
resource = CastPipeResource(pCreateSRView->hDrvResource);
format = FormatTranslate(pCreateSRView->Format, FALSE);
u_sampler_view_default_template(&desc,
resource,
format);
switch (pCreateSRView->ResourceDimension) {
case D3D10DDIRESOURCE_BUFFER: {
const struct util_format_description *fdesc = util_format_description(format);
desc.u.buf.offset = pCreateSRView->Buffer.FirstElement *
(fdesc->block.bits / 8) * fdesc->block.width;
desc.u.buf.size = pCreateSRView->Buffer.NumElements *
(fdesc->block.bits / 8) * fdesc->block.width;
}
break;
case D3D10DDIRESOURCE_TEXTURE1D:
desc.u.tex.first_level = pCreateSRView->Tex1D.MostDetailedMip;
desc.u.tex.last_level = pCreateSRView->Tex1D.MipLevels - 1 + desc.u.tex.first_level;
desc.u.tex.first_layer = pCreateSRView->Tex1D.FirstArraySlice;
desc.u.tex.last_layer = pCreateSRView->Tex1D.ArraySize - 1 + desc.u.tex.first_layer;
assert(pCreateSRView->Tex1D.MipLevels != 0 && pCreateSRView->Tex1D.MipLevels != (UINT)-1);
assert(pCreateSRView->Tex1D.ArraySize != 0 && pCreateSRView->Tex1D.ArraySize != (UINT)-1);
break;
case D3D10DDIRESOURCE_TEXTURE2D:
desc.u.tex.first_level = pCreateSRView->Tex2D.MostDetailedMip;
desc.u.tex.last_level = pCreateSRView->Tex2D.MipLevels - 1 + desc.u.tex.first_level;
desc.u.tex.first_layer = pCreateSRView->Tex2D.FirstArraySlice;
desc.u.tex.last_layer = pCreateSRView->Tex2D.ArraySize - 1 + desc.u.tex.first_layer;
assert(pCreateSRView->Tex2D.MipLevels != 0 && pCreateSRView->Tex2D.MipLevels != (UINT)-1);
assert(pCreateSRView->Tex2D.ArraySize != 0 && pCreateSRView->Tex2D.ArraySize != (UINT)-1);
break;
case D3D10DDIRESOURCE_TEXTURE3D:
desc.u.tex.first_level = pCreateSRView->Tex3D.MostDetailedMip;
desc.u.tex.last_level = pCreateSRView->Tex3D.MipLevels - 1 + desc.u.tex.first_level;
/* layer info filled in by default_template */
assert(pCreateSRView->Tex3D.MipLevels != 0 && pCreateSRView->Tex3D.MipLevels != (UINT)-1);
break;
case D3D10DDIRESOURCE_TEXTURECUBE:
desc.u.tex.first_level = pCreateSRView->TexCube.MostDetailedMip;
desc.u.tex.last_level = pCreateSRView->TexCube.MipLevels - 1 + desc.u.tex.first_level;
desc.u.tex.first_layer = pCreateSRView->TexCube.First2DArrayFace;
desc.u.tex.last_layer = 6*pCreateSRView->TexCube.NumCubes - 1 +
pCreateSRView->TexCube.First2DArrayFace;
assert(pCreateSRView->TexCube.MipLevels != 0 && pCreateSRView->TexCube.MipLevels != (UINT)-1);
break;
default:
assert(0);
return;
}
pSRView->handle = pipe->create_sampler_view(pipe, resource, &desc);
}
/*
* ----------------------------------------------------------------------
*
* DestroyShaderResourceView --
*
* The DestroyShaderResourceView function destroys the specified
* shader resource view object. The shader resource view object
* can be destoyed only if it is not currently bound to a
* display device.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
DestroyShaderResourceView(D3D10DDI_HDEVICE hDevice, // IN
D3D10DDI_HSHADERRESOURCEVIEW hShaderResourceView) // IN
{
LOG_ENTRYPOINT();
ShaderResourceView *pSRView = CastShaderResourceView(hShaderResourceView);
pipe_sampler_view_reference(&pSRView->handle, NULL);
}
/*
* ----------------------------------------------------------------------
*
* GenMips --
*
* The GenMips function generates the lower MIP-map levels
* on the specified shader-resource view.
*
* ----------------------------------------------------------------------
*/
void APIENTRY
GenMips(D3D10DDI_HDEVICE hDevice, // IN
D3D10DDI_HSHADERRESOURCEVIEW hShaderResourceView) // IN
{
LOG_ENTRYPOINT();
Device *pDevice = CastDevice(hDevice);
if (!CheckPredicate(pDevice)) {
return;
}
struct pipe_context *pipe = pDevice->pipe;
struct pipe_sampler_view *sampler_view = CastPipeShaderResourceView(hShaderResourceView);
util_gen_mipmap(pipe,
sampler_view->texture,
sampler_view->format,
sampler_view->u.tex.first_level,
sampler_view->u.tex.last_level,
sampler_view->u.tex.first_layer,
sampler_view->u.tex.last_layer,
PIPE_TEX_FILTER_LINEAR);
}
unsigned
ShaderFindOutputMapping(Shader *shader, unsigned registerIndex)
{
if (!shader || !shader->state.tokens)
return registerIndex;
for (unsigned i = 0; i < PIPE_MAX_SHADER_OUTPUTS; ++i) {
if (shader->output_mapping[i] == registerIndex)
return i;
}
return registerIndex;
}
Reference in New Issue View Git Blame Copy Permalink