forked from KolibriOS/kolibrios
399 lines
11 KiB
C
399 lines
11 KiB
C
/**************************************************************************
|
|
*
|
|
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
|
|
* 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 above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial portions
|
|
* of the Software.
|
|
*
|
|
* 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 TUNGSTEN GRAPHICS 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.
|
|
*
|
|
**************************************************************************/
|
|
|
|
#include "sp_context.h"
|
|
#include "sp_state.h"
|
|
#include "sp_fs.h"
|
|
#include "sp_texture.h"
|
|
|
|
#include "pipe/p_defines.h"
|
|
#include "util/u_memory.h"
|
|
#include "util/u_inlines.h"
|
|
#include "util/u_pstipple.h"
|
|
#include "draw/draw_context.h"
|
|
#include "draw/draw_vs.h"
|
|
#include "draw/draw_gs.h"
|
|
#include "tgsi/tgsi_dump.h"
|
|
#include "tgsi/tgsi_scan.h"
|
|
#include "tgsi/tgsi_parse.h"
|
|
|
|
|
|
/**
|
|
* Create a new fragment shader variant.
|
|
*/
|
|
static struct sp_fragment_shader_variant *
|
|
create_fs_variant(struct softpipe_context *softpipe,
|
|
struct sp_fragment_shader *fs,
|
|
const struct sp_fragment_shader_variant_key *key)
|
|
{
|
|
struct sp_fragment_shader_variant *var;
|
|
struct pipe_shader_state *stipple_fs = NULL, *curfs = &fs->shader;
|
|
unsigned unit = 0;
|
|
|
|
#if DO_PSTIPPLE_IN_HELPER_MODULE
|
|
if (key->polygon_stipple) {
|
|
/* get new shader that implements polygon stippling */
|
|
stipple_fs = util_pstipple_create_fragment_shader(&softpipe->pipe,
|
|
curfs, &unit);
|
|
curfs = stipple_fs;
|
|
}
|
|
#endif
|
|
|
|
/* codegen, create variant object */
|
|
var = softpipe_create_fs_variant_exec(softpipe, curfs);
|
|
|
|
if (var) {
|
|
var->key = *key;
|
|
var->tokens = tgsi_dup_tokens(curfs->tokens);
|
|
var->stipple_sampler_unit = unit;
|
|
|
|
tgsi_scan_shader(var->tokens, &var->info);
|
|
|
|
/* See comments elsewhere about draw fragment shaders */
|
|
#if 0
|
|
/* draw's fs state */
|
|
var->draw_shader = draw_create_fragment_shader(softpipe->draw,
|
|
&fs->shader);
|
|
if (!var->draw_shader) {
|
|
var->delete(var);
|
|
FREE((void *) var->tokens);
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
/* insert variant into linked list */
|
|
var->next = fs->variants;
|
|
fs->variants = var;
|
|
}
|
|
|
|
if (stipple_fs) {
|
|
FREE((void *) stipple_fs->tokens);
|
|
FREE(stipple_fs);
|
|
}
|
|
|
|
return var;
|
|
}
|
|
|
|
|
|
struct sp_fragment_shader_variant *
|
|
softpipe_find_fs_variant(struct softpipe_context *sp,
|
|
struct sp_fragment_shader *fs,
|
|
const struct sp_fragment_shader_variant_key *key)
|
|
{
|
|
struct sp_fragment_shader_variant *var;
|
|
|
|
for (var = fs->variants; var; var = var->next) {
|
|
if (memcmp(&var->key, key, sizeof(*key)) == 0) {
|
|
/* found it */
|
|
return var;
|
|
}
|
|
}
|
|
|
|
return create_fs_variant(sp, fs, key);
|
|
}
|
|
|
|
|
|
static void *
|
|
softpipe_create_fs_state(struct pipe_context *pipe,
|
|
const struct pipe_shader_state *templ)
|
|
{
|
|
struct softpipe_context *softpipe = softpipe_context(pipe);
|
|
struct sp_fragment_shader *state = CALLOC_STRUCT(sp_fragment_shader);
|
|
|
|
/* debug */
|
|
if (softpipe->dump_fs)
|
|
tgsi_dump(templ->tokens, 0);
|
|
|
|
/* we need to keep a local copy of the tokens */
|
|
state->shader.tokens = tgsi_dup_tokens(templ->tokens);
|
|
|
|
/* draw's fs state */
|
|
state->draw_shader = draw_create_fragment_shader(softpipe->draw,
|
|
&state->shader);
|
|
if (!state->draw_shader) {
|
|
FREE((void *) state->shader.tokens);
|
|
FREE(state);
|
|
return NULL;
|
|
}
|
|
|
|
return state;
|
|
}
|
|
|
|
|
|
static void
|
|
softpipe_bind_fs_state(struct pipe_context *pipe, void *fs)
|
|
{
|
|
struct softpipe_context *softpipe = softpipe_context(pipe);
|
|
struct sp_fragment_shader *state = (struct sp_fragment_shader *) fs;
|
|
|
|
if (softpipe->fs == fs)
|
|
return;
|
|
|
|
draw_flush(softpipe->draw);
|
|
|
|
softpipe->fs = fs;
|
|
|
|
/* This depends on the current fragment shader and must always be
|
|
* re-validated before use.
|
|
*/
|
|
softpipe->fs_variant = NULL;
|
|
|
|
if (state)
|
|
draw_bind_fragment_shader(softpipe->draw,
|
|
state->draw_shader);
|
|
else
|
|
draw_bind_fragment_shader(softpipe->draw, NULL);
|
|
|
|
softpipe->dirty |= SP_NEW_FS;
|
|
}
|
|
|
|
|
|
static void
|
|
softpipe_delete_fs_state(struct pipe_context *pipe, void *fs)
|
|
{
|
|
struct softpipe_context *softpipe = softpipe_context(pipe);
|
|
struct sp_fragment_shader *state = fs;
|
|
struct sp_fragment_shader_variant *var, *next_var;
|
|
|
|
assert(fs != softpipe->fs);
|
|
|
|
/* delete variants */
|
|
for (var = state->variants; var; var = next_var) {
|
|
next_var = var->next;
|
|
|
|
assert(var != softpipe->fs_variant);
|
|
|
|
/* See comments elsewhere about draw fragment shaders */
|
|
#if 0
|
|
draw_delete_fragment_shader(softpipe->draw, var->draw_shader);
|
|
#endif
|
|
|
|
var->delete(var, softpipe->fs_machine);
|
|
}
|
|
|
|
draw_delete_fragment_shader(softpipe->draw, state->draw_shader);
|
|
|
|
FREE((void *) state->shader.tokens);
|
|
FREE(state);
|
|
}
|
|
|
|
|
|
static void *
|
|
softpipe_create_vs_state(struct pipe_context *pipe,
|
|
const struct pipe_shader_state *templ)
|
|
{
|
|
struct softpipe_context *softpipe = softpipe_context(pipe);
|
|
struct sp_vertex_shader *state;
|
|
|
|
state = CALLOC_STRUCT(sp_vertex_shader);
|
|
if (state == NULL )
|
|
goto fail;
|
|
|
|
/* copy shader tokens, the ones passed in will go away.
|
|
*/
|
|
state->shader.tokens = tgsi_dup_tokens(templ->tokens);
|
|
if (state->shader.tokens == NULL)
|
|
goto fail;
|
|
|
|
state->draw_data = draw_create_vertex_shader(softpipe->draw, templ);
|
|
if (state->draw_data == NULL)
|
|
goto fail;
|
|
|
|
state->max_sampler = state->draw_data->info.file_max[TGSI_FILE_SAMPLER];
|
|
|
|
return state;
|
|
|
|
fail:
|
|
if (state) {
|
|
FREE( (void *)state->shader.tokens );
|
|
FREE( state->draw_data );
|
|
FREE( state );
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static void
|
|
softpipe_bind_vs_state(struct pipe_context *pipe, void *vs)
|
|
{
|
|
struct softpipe_context *softpipe = softpipe_context(pipe);
|
|
|
|
softpipe->vs = (struct sp_vertex_shader *) vs;
|
|
|
|
draw_bind_vertex_shader(softpipe->draw,
|
|
(softpipe->vs ? softpipe->vs->draw_data : NULL));
|
|
|
|
softpipe->dirty |= SP_NEW_VS;
|
|
}
|
|
|
|
|
|
static void
|
|
softpipe_delete_vs_state(struct pipe_context *pipe, void *vs)
|
|
{
|
|
struct softpipe_context *softpipe = softpipe_context(pipe);
|
|
|
|
struct sp_vertex_shader *state = (struct sp_vertex_shader *) vs;
|
|
|
|
draw_delete_vertex_shader(softpipe->draw, state->draw_data);
|
|
FREE( (void *)state->shader.tokens );
|
|
FREE( state );
|
|
}
|
|
|
|
|
|
static void *
|
|
softpipe_create_gs_state(struct pipe_context *pipe,
|
|
const struct pipe_shader_state *templ)
|
|
{
|
|
struct softpipe_context *softpipe = softpipe_context(pipe);
|
|
struct sp_geometry_shader *state;
|
|
|
|
state = CALLOC_STRUCT(sp_geometry_shader);
|
|
if (state == NULL )
|
|
goto fail;
|
|
|
|
state->shader = *templ;
|
|
|
|
if (templ->tokens) {
|
|
/* debug */
|
|
if (softpipe->dump_gs)
|
|
tgsi_dump(templ->tokens, 0);
|
|
|
|
/* copy shader tokens, the ones passed in will go away.
|
|
*/
|
|
state->shader.tokens = tgsi_dup_tokens(templ->tokens);
|
|
if (state->shader.tokens == NULL)
|
|
goto fail;
|
|
|
|
state->draw_data = draw_create_geometry_shader(softpipe->draw, templ);
|
|
if (state->draw_data == NULL)
|
|
goto fail;
|
|
|
|
state->max_sampler = state->draw_data->info.file_max[TGSI_FILE_SAMPLER];
|
|
}
|
|
|
|
return state;
|
|
|
|
fail:
|
|
if (state) {
|
|
FREE( (void *)state->shader.tokens );
|
|
FREE( state->draw_data );
|
|
FREE( state );
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static void
|
|
softpipe_bind_gs_state(struct pipe_context *pipe, void *gs)
|
|
{
|
|
struct softpipe_context *softpipe = softpipe_context(pipe);
|
|
|
|
softpipe->gs = (struct sp_geometry_shader *)gs;
|
|
|
|
draw_bind_geometry_shader(softpipe->draw,
|
|
(softpipe->gs ? softpipe->gs->draw_data : NULL));
|
|
|
|
softpipe->dirty |= SP_NEW_GS;
|
|
}
|
|
|
|
|
|
static void
|
|
softpipe_delete_gs_state(struct pipe_context *pipe, void *gs)
|
|
{
|
|
struct softpipe_context *softpipe = softpipe_context(pipe);
|
|
|
|
struct sp_geometry_shader *state =
|
|
(struct sp_geometry_shader *)gs;
|
|
|
|
draw_delete_geometry_shader(softpipe->draw,
|
|
(state) ? state->draw_data : 0);
|
|
|
|
FREE((void *) state->shader.tokens);
|
|
FREE(state);
|
|
}
|
|
|
|
|
|
static void
|
|
softpipe_set_constant_buffer(struct pipe_context *pipe,
|
|
uint shader, uint index,
|
|
struct pipe_constant_buffer *cb)
|
|
{
|
|
struct softpipe_context *softpipe = softpipe_context(pipe);
|
|
struct pipe_resource *constants = cb ? cb->buffer : NULL;
|
|
unsigned size;
|
|
const void *data;
|
|
|
|
if (cb && cb->user_buffer) {
|
|
constants = softpipe_user_buffer_create(pipe->screen,
|
|
(void *) cb->user_buffer,
|
|
cb->buffer_size,
|
|
PIPE_BIND_CONSTANT_BUFFER);
|
|
}
|
|
|
|
size = constants ? constants->width0 : 0;
|
|
data = constants ? softpipe_resource(constants)->data : NULL;
|
|
|
|
assert(shader < PIPE_SHADER_TYPES);
|
|
|
|
draw_flush(softpipe->draw);
|
|
|
|
/* note: reference counting */
|
|
pipe_resource_reference(&softpipe->constants[shader][index], constants);
|
|
|
|
if (shader == PIPE_SHADER_VERTEX || shader == PIPE_SHADER_GEOMETRY) {
|
|
draw_set_mapped_constant_buffer(softpipe->draw, shader, index, data, size);
|
|
}
|
|
|
|
softpipe->mapped_constants[shader][index] = data;
|
|
softpipe->const_buffer_size[shader][index] = size;
|
|
|
|
softpipe->dirty |= SP_NEW_CONSTANTS;
|
|
|
|
if (cb && cb->user_buffer) {
|
|
pipe_resource_reference(&constants, NULL);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
softpipe_init_shader_funcs(struct pipe_context *pipe)
|
|
{
|
|
pipe->create_fs_state = softpipe_create_fs_state;
|
|
pipe->bind_fs_state = softpipe_bind_fs_state;
|
|
pipe->delete_fs_state = softpipe_delete_fs_state;
|
|
|
|
pipe->create_vs_state = softpipe_create_vs_state;
|
|
pipe->bind_vs_state = softpipe_bind_vs_state;
|
|
pipe->delete_vs_state = softpipe_delete_vs_state;
|
|
|
|
pipe->create_gs_state = softpipe_create_gs_state;
|
|
pipe->bind_gs_state = softpipe_bind_gs_state;
|
|
pipe->delete_gs_state = softpipe_delete_gs_state;
|
|
|
|
pipe->set_constant_buffer = softpipe_set_constant_buffer;
|
|
}
|