blob: 01de6a18bce48f4484ffe8a153ac62ed12ca0d1d [file] [log] [blame]
/*
* Copyright 2009, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// This file contains definitions for resource flags, enums, and helper
// functions.
#ifndef GPU_COMMAND_BUFFER_COMMON_CROSS_RESOURCE_H_
#define GPU_COMMAND_BUFFER_COMMON_CROSS_RESOURCE_H_
#include <algorithm>
#include "base/basictypes.h"
#include "base/scoped_ptr.h"
#include "gpu/command_buffer/common/types.h"
#include "gpu/command_buffer/common/logging.h"
namespace command_buffer {
// A resource ID, key to the resource maps.
typedef uint32 ResourceId;
// Invalid resource ID.
static const ResourceId kInvalidResource = 0xffffffffU;
namespace vertex_buffer {
// Vertex buffer flags.
enum Flags {
kNone = 0x00,
kDynamic = 0x01, // This vertex buffer is dynamic and is expected to have
// its data updated often.
};
} // namespace vertex_buffer
namespace index_buffer {
// Index buffer flags.
enum Flags {
kNone = 0x00,
kDynamic = 0x01, // This index buffer is dynamic and is expected to have
// its data updated often.
kIndex32Bit = 0x02, // Indices contained in this index buffer are 32 bits
// (unsigned int) instead of 16 bit (unsigned short).
};
} // namespace index_buffer
namespace vertex_struct {
// Semantics for input data.
enum Semantic {
kUnknownSemantic = -1,
kPosition = 0,
kNormal,
kColor,
kTexCoord,
kNumSemantics
};
// Input data types.
enum Type {
kFloat1,
kFloat2,
kFloat3,
kFloat4,
kUChar4N,
kNumTypes
};
} // namespace vertex_struct
namespace effect_param {
enum DataType {
kUnknown, // A parameter exists in the effect, but the type is not
// representable (e.g. MATRIX3x4).
kFloat1,
kFloat2,
kFloat3,
kFloat4,
kMatrix4,
kInt,
kBool,
kSampler,
kTexture,
kNumTypes,
kMake32Bit = 0x7fffffff,
};
COMPILE_ASSERT(sizeof(DataType) == 4, DataType_should_be_32_bits);
// Gets the size of the data of a particular type.
unsigned int GetDataSize(DataType type);
// Structure describing a parameter, filled in by the
// GAPIInterface::GetParamDesc call.
struct Desc {
Uint32 size; // the total memory size needed for the complete
// description.
Uint32 name_offset; // the offset of the parameter name, relative to
// the beginning of the structure. May be 0 if the
// name doesn't fit into the memory buffer.
Uint32 name_size; // the size of the parameter name, including the
// terminating nul character. Will always be set
// even if the name doesn't fit into the buffer.
Uint32 semantic_offset; // the offset of the parameter semantic, relative
// to the beginning of the structure. May be 0 if
// the semantic doesn't fit into the memory
// buffer.
Uint32 semantic_size; // the size of the parameter semantic, including
// the terminating nul character. Will always be
// set even if the semantic doesn't fit into the
// buffer.
Uint32 num_elements; // the number of entries if the parameter is an array
// 0 otherwise.
DataType data_type; // the data type of the parameter.
Uint32 data_size; // the size of the parameter data, in bytes.
};
} // namespace effect_param
namespace effect_stream {
struct Desc {
Desc()
: semantic(vertex_struct::kUnknownSemantic),
semantic_index(0) {}
Desc(Uint32 semantic, Uint32 semantic_index)
: semantic(semantic),
semantic_index(semantic_index) {}
Uint32 semantic; // the semantic type
Uint32 semantic_index;
};
} // namespace effect_stream
namespace texture {
// Texture flags.
enum Flags {
kNone = 0x00,
kDynamic = 0x01, // This texture is dynamic and is expected to have
// its data updated often.
};
// Texel formats.
enum Format {
kUnknown,
kXRGB8,
kARGB8,
kABGR16F,
kR32F,
kABGR32F,
kDXT1
};
// Texture type.
enum Type {
kTexture2d,
kTexture3d,
kTextureCube,
};
// Cube map face.
enum Face {
kFacePositiveX,
kFaceNegativeX,
kFacePositiveY,
kFaceNegativeY,
kFacePositiveZ,
kFaceNegativeZ,
kFaceNone = kFacePositiveX, // For non-cube maps.
};
// Gets the number of bytes per block for a given texture format. For most
// texture formats, a block is 1x1 texels, but DXT* formats have 4x4 blocks.
unsigned int GetBytesPerBlock(Format format);
// Gets the x dimension of a texel block for a given texture format. For most
// texture formats, a block is 1x1 texels, but DXT* formats have 4x4 blocks.
unsigned int GetBlockSizeX(Format format);
// Gets the y dimension of a texel block for a given texture format. For most
// texture formats, a block is 1x1 texels, but DXT* formats have 4x4 blocks.
unsigned int GetBlockSizeY(Format format);
// Gets the dimension of a mipmap level given the dimension of the base
// level. Every mipmap level is half the size of the previous level, rounding
// down.
inline unsigned int GetMipMapDimension(unsigned int base,
unsigned int level) {
DCHECK_GT(base, 0U);
return std::max(1U, base >> level);
}
} // namespace texture
namespace sampler {
enum AddressingMode {
kWrap,
kMirrorRepeat,
kClampToEdge,
kClampToBorder,
kNumAddressingMode
};
enum FilteringMode {
kNone,
kPoint,
kLinear,
kNumFilteringMode
};
} // namespace sampler
} // namespace command_buffer
#endif // GPU_COMMAND_BUFFER_COMMON_CROSS_RESOURCE_H_