PatchCollectionPointer Quad::splitIntoPatches() const {
VertexPointer vertex0 = VertexPointer(new Vertex(mVertex0));
VertexPointer vertex1 = VertexPointer(new Vertex(mVertex1));
VertexPointer vertex2 = VertexPointer(new Vertex(mVertex2));
VertexPointer vertex3 = VertexPointer(new Vertex(mVertex3));
PatchCollectionPointer patches = PatchCollectionPointer(new PatchCollection());
patches->addPatch(TrianglePatchPointer(new TrianglePatch(vertex0, vertex1, vertex2, getMaterial())));
patches->addPatch(TrianglePatchPointer(new TrianglePatch(vertex0, vertex2, vertex3, getMaterial())));
return patches;
}
void VertexBufferManager::InitDefaultDeclarations()
{
/*struct Vertex
{
glm::vec3 Position;
glm::vec3 Normal;
glm::vec2 TexCoord;
};*/
VertexPointer Pointer[3] = {
VertexPointer( 0, 3, 8 * sizeof( float ), V_POSITION, (void*) NULL ), // wskaĊ¸nik na pozycje
VertexPointer( 1, 3, 8 * sizeof( float ), V_NORMAL, (void*) (sizeof( float ) *3 ) ), // wskaĊ¸nik na normalna
VertexPointer( 2, 2, 8 * sizeof( float ), V_TEXCOORD, (void*) (sizeof( float ) *6 ) ) // wskaxnik na tex coordy
};
CreateVertexDeclaration( "Default", Pointer, 3 );
}
/**
* Split patch into 4 smaller patches.
*/
PatchCollectionPointer TrianglePatch::split() const {
Vector edgeCenter0 = (mVertex0->getCoordinates() + mVertex1->getCoordinates()) * 0.5f;
Vector edgeCenter1 = (mVertex1->getCoordinates() + mVertex2->getCoordinates()) * 0.5f;
Vector edgeCenter2 = (mVertex0->getCoordinates() + mVertex2->getCoordinates()) * 0.5f;
VertexPointer edgeCenter0Vertex = VertexPointer(new Vertex(edgeCenter0));
VertexPointer edgeCenter1Vertex = VertexPointer(new Vertex(edgeCenter1));
VertexPointer edgeCenter2Vertex = VertexPointer(new Vertex(edgeCenter2));
PatchCollectionPointer newPatches = PatchCollectionPointer(new PatchCollection());
newPatches->addPatch(TrianglePatchPointer(new TrianglePatch(mVertex0, edgeCenter0Vertex, edgeCenter2Vertex, getMaterial())));
newPatches->addPatch(TrianglePatchPointer(new TrianglePatch(mVertex1, edgeCenter1Vertex, edgeCenter0Vertex, getMaterial())));
newPatches->addPatch(TrianglePatchPointer(new TrianglePatch(mVertex2, edgeCenter2Vertex, edgeCenter1Vertex, getMaterial())));
newPatches->addPatch(TrianglePatchPointer(new TrianglePatch(edgeCenter0Vertex, edgeCenter1Vertex, edgeCenter2Vertex, getMaterial())));
return newPatches;
}
inline void PointVertexArray_testSelect(VertexCb* first, std::size_t count,
SelectionTest& test, SelectionIntersection& best)
{
test.TestLineStrip(
VertexPointer(&first->vertex, sizeof(VertexCb)),
IndexPointer::index_type(count),
best
);
}
inline void PointVertexArray_testSelect(PointVertex* first, std::size_t count, SelectionTest& test, SelectionIntersection& best)
{
test.TestLineStrip(
VertexPointer(
reinterpret_cast<VertexPointer::pointer>(&first->vertex),
sizeof(PointVertex)
),
IndexPointer::index_type(count),
best
);
}
// Perform selection test for this surface
void RenderablePicoSurface::testSelect(Selector& selector,
SelectionTest& test,
const Matrix4& localToWorld) const
{
if (!_vertices.empty() && !_indices.empty())
{
// Test for triangle selection
test.BeginMesh(localToWorld);
SelectionIntersection result;
test.TestTriangles(
VertexPointer(&_vertices[0].vertex, sizeof(ArbitraryMeshVertex)),
IndexPointer(&_indices[0],
IndexPointer::index_type(_indices.size())),
result
);
// Add the intersection to the selector if it is valid
if(result.valid()) {
selector.addIntersection(result);
}
}
}
void Winding::testSelect(SelectionTest& test, SelectionIntersection& best)
{
if (empty()) return;
test.TestPolygon(VertexPointer(&front().vertex, sizeof(WindingVertex)), size(), best);
}
void GrGpuGLFixed::setupGeometry(int* startVertex,
int* startIndex,
int vertexCount,
int indexCount) {
int newColorOffset;
int newTexCoordOffsets[kNumStages];
GrGLsizei newStride = VertexSizeAndOffsetsByStage(fGeometrySrc.fVertexLayout,
newTexCoordOffsets,
&newColorOffset);
int oldColorOffset;
int oldTexCoordOffsets[kNumStages];
GrGLsizei oldStride = VertexSizeAndOffsetsByStage(fHWGeometryState.fVertexLayout,
oldTexCoordOffsets,
&oldColorOffset);
bool indexed = NULL != startIndex;
int extraVertexOffset;
int extraIndexOffset;
setBuffers(indexed, &extraVertexOffset, &extraIndexOffset);
GrGLenum scalarType;
if (fGeometrySrc.fVertexLayout & kTextFormat_VertexLayoutBit) {
scalarType = GrGLTextType;
} else {
scalarType = GrGLType;
}
size_t vertexOffset = (*startVertex + extraVertexOffset) * newStride;
*startVertex = 0;
if (indexed) {
*startIndex += extraIndexOffset;
}
// all the Pointers must be set if any of these are true
bool allOffsetsChange = fHWGeometryState.fArrayPtrsDirty ||
vertexOffset != fHWGeometryState.fVertexOffset ||
newStride != oldStride;
// position and tex coord offsets change if above conditions are true
// or the type changed based on text vs nontext type coords.
bool posAndTexChange = allOffsetsChange ||
((GrGLTextType != GrGLType) &&
(kTextFormat_VertexLayoutBit &
(fHWGeometryState.fVertexLayout ^
fGeometrySrc.fVertexLayout)));
if (posAndTexChange) {
GR_GL(VertexPointer(2, scalarType, newStride, (GrGLvoid*)vertexOffset));
fHWGeometryState.fVertexOffset = vertexOffset;
}
for (int s = 0; s < kNumStages; ++s) {
// need to enable array if tex coord offset is 0
// (using positions as coords)
if (newTexCoordOffsets[s] >= 0) {
GrGLvoid* texCoordOffset = (GrGLvoid*)(vertexOffset + newTexCoordOffsets[s]);
if (oldTexCoordOffsets[s] < 0) {
GR_GL(ClientActiveTexture(GR_GL_TEXTURE0+s));
GR_GL(EnableClientState(GR_GL_TEXTURE_COORD_ARRAY));
GR_GL(TexCoordPointer(2, scalarType, newStride, texCoordOffset));
} else if (posAndTexChange ||
newTexCoordOffsets[s] != oldTexCoordOffsets[s]) {
GR_GL(ClientActiveTexture(GR_GL_TEXTURE0+s));
GR_GL(TexCoordPointer(2, scalarType, newStride, texCoordOffset));
}
} else if (oldTexCoordOffsets[s] >= 0) {
GR_GL(ClientActiveTexture(GR_GL_TEXTURE0+s));
GR_GL(DisableClientState(GR_GL_TEXTURE_COORD_ARRAY));
}
}
if (newColorOffset > 0) {
GrGLvoid* colorOffset = (GrGLvoid*)(vertexOffset + newColorOffset);
if (oldColorOffset <= 0) {
GR_GL(EnableClientState(GR_GL_COLOR_ARRAY));
GR_GL(ColorPointer(4, GR_GL_UNSIGNED_BYTE, newStride, colorOffset));
} else if (allOffsetsChange || newColorOffset != oldColorOffset) {
GR_GL(ColorPointer(4, GR_GL_UNSIGNED_BYTE, newStride, colorOffset));
}
} else if (oldColorOffset > 0) {
GR_GL(DisableClientState(GR_GL_COLOR_ARRAY));
}
fHWGeometryState.fVertexLayout = fGeometrySrc.fVertexLayout;
fHWGeometryState.fArrayPtrsDirty = false;
}
inline VertexPointer vertexpointer_arbitrarymeshvertex(const ArbitraryMeshVertex* array)
{
return VertexPointer(&array->vertex, sizeof(ArbitraryMeshVertex));
}
