| /* |
| Copyright (c) 2011-2012 NVIDIA Corporation |
| Copyright (c) 2011-2012 Cass Everitt |
| Copyright (c) 2012 Scott Nations |
| Copyright (c) 2012 Mathias Schott |
| Copyright (c) 2012 Nigel Stewart |
| Copyright (c) 2013 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. |
| |
| 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 HOLDER 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. |
| */ |
| |
| #include "gtest/gtest.h" |
| #include "gmock/gmock.h" |
| |
| #include "RegalContext.h" |
| #include "RegalContextInfo.h" |
| #include "RegalDispatchGMock.h" |
| #include "RegalPpca.h" |
| |
| namespace { |
| |
| using namespace Regal; |
| using namespace Regal::Emu; |
| |
| using ::testing::Mock; |
| using ::testing::_; |
| using ::testing::AnyNumber; |
| |
| |
| template <typename T, size_t N> size_t arraysize( const T( & )[ N ] ) { |
| return N; |
| } |
| |
| void checkNamedVertexArrayDefaults(ClientState::NamedVertexArray& nva, GLuint n) |
| { |
| EXPECT_EQ( GLboolean(GL_FALSE), nva.enabled ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>(NULL), nva.pointer ); |
| EXPECT_EQ( GLuint(0), nva.buffer ); |
| EXPECT_EQ( GLint(0), nva.stride ); |
| |
| if (n == ClientState::FOG_COORD || |
| n == ClientState::INDEX || |
| n == ClientState::EDGE_FLAG) |
| EXPECT_EQ( GLint(1), nva.size ); |
| else if (n == ClientState::NORMAL || |
| n == ClientState::SECONDARY_COLOR) |
| EXPECT_EQ( GLint(3), nva.size ); |
| else |
| EXPECT_EQ( GLint(4), nva.size ); |
| |
| if (n == ClientState::EDGE_FLAG) |
| EXPECT_EQ( GLenum(GL_BOOL), nva.type ); |
| else |
| EXPECT_EQ( GLenum(GL_FLOAT), nva.type ); |
| } |
| |
| void checkVertexBufferBindPointDefaults(ClientState::VertexBufferBindPoint& vbbp) |
| { |
| EXPECT_EQ( GLuint(0), vbbp.buffer ); |
| EXPECT_EQ( GLintptr(0), vbbp.offset ); |
| EXPECT_EQ( GLsizei(16), vbbp.stride ); |
| EXPECT_EQ( GLuint(0), vbbp.divisor ); |
| } |
| |
| void checkGenericVertexArrayDefaults(ClientState::GenericVertexArray& gva, GLuint index) |
| { |
| EXPECT_EQ( GLboolean(GL_FALSE), gva.enabled ); |
| EXPECT_EQ( GLuint(4), gva.size ); |
| EXPECT_EQ( GLenum(GL_FLOAT), gva.type ); |
| EXPECT_EQ( GLuint(0), gva.relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), gva.normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), gva.isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), gva.isLong ); |
| EXPECT_EQ( index, gva.bindingIndex ); |
| } |
| |
| void checkVertexArrayDefaults(ClientState::VertexArray& va) |
| { |
| EXPECT_EQ( GLuint(0), va.elementArrayBufferBinding ); |
| EXPECT_EQ( GLenum(GL_TEXTURE0), va.clientActiveTexture ); |
| EXPECT_EQ( GLboolean(GL_FALSE), va.primitiveRestartFixedIndex ); |
| EXPECT_EQ( GLboolean(GL_FALSE), va.primitiveRestart ); |
| EXPECT_EQ( GLuint(0), va.primitiveRestartIndex ); |
| EXPECT_EQ( GLuint(0), va.arrayBufferBinding ); |
| EXPECT_EQ( GLuint(0), va.vertexArrayBinding ); |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| checkNamedVertexArrayDefaults( va.named[ii], ii ); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| checkVertexBufferBindPointDefaults( va.bindings[ii] ); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS; ii++) |
| checkGenericVertexArrayDefaults( va.generic[ii], ii ); |
| } |
| |
| void checkPixelStoreDefaults(ClientState::PixelStore& ps) |
| { |
| EXPECT_EQ( GLboolean(GL_FALSE), ps.unpackSwapBytes ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ps.unpackLsbFirst ); |
| EXPECT_EQ( GLint(0), ps.unpackImageHeight ); |
| EXPECT_EQ( GLint(0), ps.unpackSkipImages ); |
| EXPECT_EQ( GLint(0), ps.unpackRowLength ); |
| EXPECT_EQ( GLint(0), ps.unpackSkipRows ); |
| EXPECT_EQ( GLint(0), ps.unpackSkipPixels ); |
| EXPECT_EQ( GLint(4), ps.unpackAlignment ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ps.packSwapBytes ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ps.packLsbFirst ); |
| EXPECT_EQ( GLint(0), ps.packImageHeight ); |
| EXPECT_EQ( GLint(0), ps.packSkipImages ); |
| EXPECT_EQ( GLint(0), ps.packRowLength ); |
| EXPECT_EQ( GLint(0), ps.packSkipRows ); |
| EXPECT_EQ( GLint(0), ps.packSkipPixels ); |
| EXPECT_EQ( GLint(4), ps.packAlignment ); |
| EXPECT_EQ( GLuint(0), ps.pixelUnpackBufferBinding ); |
| EXPECT_EQ( GLuint(0), ps.pixelPackBufferBinding ); |
| } |
| |
| void checkPpcaDefaults(RegalContext& ctx, Ppca& ppca) |
| { |
| GLint clientAttribStackDepth = 666; |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv(ctx, GL_CLIENT_ATTRIB_STACK_DEPTH, &clientAttribStackDepth)); |
| EXPECT_EQ( clientAttribStackDepth, GLint(0) ); |
| |
| EXPECT_EQ( std::vector<GLbitfield>::size_type(0), ppca.maskStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(0), ppca.vertexArrayStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(0), ppca.pixelStoreStack.size() ); |
| |
| checkVertexArrayDefaults(ppca); |
| checkPixelStoreDefaults(ppca); |
| } |
| |
| TEST ( RegalPpca, Ppca_Defaults ) |
| { |
| RegalGMockInterface mock; |
| |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| ctx.info->core = false; |
| ctx.info->es1 = false; |
| ctx.info->es2 = false; |
| InitDispatchTableGMock( ctx.dispatcher.emulation ); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| GLint maxClientAttribStackDepth = 0; |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv( ctx, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, &maxClientAttribStackDepth ) ); |
| EXPECT_GE( maxClientAttribStackDepth, GLint(16) ); |
| |
| const GLbitfield remainder = ~( GL_CLIENT_PIXEL_STORE_BIT | GL_CLIENT_VERTEX_ARRAY_BIT ); |
| EXPECT_CALL( mock, glPushClientAttrib( remainder ) ); |
| |
| ppca.glPushClientAttrib( ctx, GL_CLIENT_ALL_ATTRIB_BITS ); |
| Mock::VerifyAndClear( &mock ); |
| |
| GLint clientAttribStackDepth = 666; |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv(ctx, GL_CLIENT_ATTRIB_STACK_DEPTH, &clientAttribStackDepth)); |
| EXPECT_EQ( GLint(1), clientAttribStackDepth ); |
| |
| EXPECT_EQ( std::vector<GLbitfield>::size_type(1), ppca.maskStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(1), ppca.vertexArrayStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(1), ppca.pixelStoreStack.size() ); |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| TEST ( RegalPpca, VertexArray_Defaults ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::elementArrayBufferBinding = GLuint(6); |
| ppca.VertexArray::clientActiveTexture = GLenum(6); |
| ppca.VertexArray::primitiveRestartFixedIndex = GLboolean(GL_TRUE); |
| ppca.VertexArray::primitiveRestart = GLboolean(GL_TRUE); |
| ppca.VertexArray::primitiveRestartIndex = GLuint(6); |
| ppca.VertexArray::arrayBufferBinding = GLuint(6); |
| ppca.VertexArray::vertexArrayBinding = GLuint(6); |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| ppca.VertexArray::named[ii].enabled = GLboolean(GL_TRUE); |
| ppca.VertexArray::named[ii].pointer = reinterpret_cast<const GLvoid*>(77); |
| ppca.VertexArray::named[ii].buffer = GLuint(77); |
| ppca.VertexArray::named[ii].size = GLint(77); |
| ppca.VertexArray::named[ii].type = GLenum(77); |
| ppca.VertexArray::named[ii].stride = GLuint(77); |
| } |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.VertexArray::bindings[ii].buffer = GLuint(888); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(888); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(888); |
| ppca.VertexArray::bindings[ii].divisor = GLuint(888); |
| } |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS; ii++) |
| { |
| ppca.VertexArray::generic[ii].enabled = GLboolean(9999); |
| ppca.VertexArray::generic[ii].size = GLuint(9999); |
| ppca.VertexArray::generic[ii].type = GLenum(9999); |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(9999); |
| ppca.VertexArray::generic[ii].normalized = GLboolean(9999); |
| ppca.VertexArray::generic[ii].isInteger = GLboolean(9999); |
| ppca.VertexArray::generic[ii].isLong = GLboolean(9999); |
| ppca.VertexArray::generic[ii].bindingIndex = GLuint(9999); |
| } |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| TEST ( RegalPpca, PixelStore_Defaults ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.PixelStore::unpackSwapBytes = GL_TRUE; |
| ppca.PixelStore::unpackLsbFirst = GL_TRUE; |
| ppca.PixelStore::unpackImageHeight = 1; |
| ppca.PixelStore::unpackSkipImages = 2; |
| ppca.PixelStore::unpackRowLength = 3; |
| ppca.PixelStore::unpackSkipRows = 4; |
| ppca.PixelStore::unpackSkipPixels = 5; |
| ppca.PixelStore::unpackAlignment = 6; |
| ppca.PixelStore::packSwapBytes = GL_TRUE; |
| ppca.PixelStore::packLsbFirst = GL_TRUE; |
| ppca.PixelStore::packImageHeight = 7; |
| ppca.PixelStore::packSkipImages = 8; |
| ppca.PixelStore::packRowLength = 9; |
| ppca.PixelStore::packSkipRows = 10; |
| ppca.PixelStore::packSkipPixels = 11; |
| ppca.PixelStore::packAlignment = 12; |
| ppca.PixelStore::pixelUnpackBufferBinding = 13; |
| ppca.PixelStore::pixelPackBufferBinding = 14; |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| TEST ( RegalPpca, VertexArray_Swap ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca state; |
| checkPpcaDefaults(ctx, state); |
| |
| state.VertexArray::elementArrayBufferBinding = GLuint(1); |
| state.VertexArray::clientActiveTexture = GLenum(2); |
| state.VertexArray::primitiveRestartFixedIndex = GLboolean(GL_TRUE); |
| state.VertexArray::primitiveRestart = GLboolean(GL_TRUE); |
| state.VertexArray::primitiveRestartIndex = GLuint(3); |
| state.VertexArray::arrayBufferBinding = GLuint(4); |
| state.VertexArray::vertexArrayBinding = GLuint(5); |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| state.VertexArray::named[ii].enabled = GLboolean(GL_TRUE); |
| state.VertexArray::named[ii].pointer = reinterpret_cast<const GLvoid*>(77); |
| state.VertexArray::named[ii].buffer = GLuint(77); |
| state.VertexArray::named[ii].size = GLint(77); |
| state.VertexArray::named[ii].type = GLenum(77); |
| state.VertexArray::named[ii].stride = GLuint(77); |
| } |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| state.VertexArray::bindings[ii].buffer = GLuint(888); |
| state.VertexArray::bindings[ii].offset = GLintptr(888); |
| state.VertexArray::bindings[ii].stride = GLsizei(888); |
| state.VertexArray::bindings[ii].divisor = GLuint(888); |
| } |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS; ii++) |
| { |
| state.VertexArray::generic[ii].enabled = GLboolean(9999); |
| state.VertexArray::generic[ii].size = GLuint(9999); |
| state.VertexArray::generic[ii].type = GLenum(9999); |
| state.VertexArray::generic[ii].relativeOffset = GLuint(9999); |
| state.VertexArray::generic[ii].normalized = GLboolean(9999); |
| state.VertexArray::generic[ii].isInteger = GLboolean(9999); |
| state.VertexArray::generic[ii].isLong = GLboolean(9999); |
| state.VertexArray::generic[ii].bindingIndex = GLuint(9999); |
| } |
| |
| Ppca other; |
| checkPpcaDefaults(ctx, other); |
| |
| other.VertexArray::swap( state ); |
| |
| checkPpcaDefaults(ctx, state); |
| |
| EXPECT_EQ( GLuint( 1 ), other.VertexArray::elementArrayBufferBinding ); |
| EXPECT_EQ( GLenum( 2 ), other.VertexArray::clientActiveTexture ); |
| EXPECT_EQ( GLboolean(GL_TRUE), other.VertexArray::primitiveRestartFixedIndex ); |
| EXPECT_EQ( GLboolean(GL_TRUE), other.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLuint(3), other.VertexArray::primitiveRestartIndex ); |
| EXPECT_EQ( GLuint(4), other.VertexArray::arrayBufferBinding ); |
| EXPECT_EQ( GLuint(5), other.VertexArray::vertexArrayBinding ); |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| EXPECT_EQ( GLboolean(GL_TRUE), other.VertexArray::named[ii].enabled ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>(77), other.VertexArray::named[ii].pointer ); |
| EXPECT_EQ( GLuint(77), other.VertexArray::named[ii].buffer ); |
| EXPECT_EQ( GLint(77), other.VertexArray::named[ii].size ); |
| EXPECT_EQ( GLenum(77), other.VertexArray::named[ii].type ); |
| EXPECT_EQ( GLuint(77), other.VertexArray::named[ii].stride ); |
| } |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| EXPECT_EQ( GLuint(888), other.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr(888), other.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(888), other.VertexArray::bindings[ii].stride ); |
| EXPECT_EQ( GLuint(888), other.VertexArray::bindings[ii].divisor ); |
| } |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS; ii++) |
| { |
| EXPECT_EQ( GLboolean(9999), other.VertexArray::generic[ii].enabled ); |
| EXPECT_EQ( GLuint(9999), other.VertexArray::generic[ii].size ); |
| EXPECT_EQ( GLenum(9999), other.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint(9999), other.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(9999), other.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(9999), other.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(9999), other.VertexArray::generic[ii].isLong ); |
| EXPECT_EQ( GLuint(9999), other.VertexArray::generic[ii].bindingIndex ); |
| } |
| } |
| |
| TEST ( RegalPpca, PixelStore_Swap ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca state; |
| checkPpcaDefaults(ctx, state); |
| |
| Ppca other; |
| checkPpcaDefaults(ctx, other); |
| |
| // Set each attribute in other to a unique value |
| |
| other.PixelStore::unpackSwapBytes = GL_TRUE; |
| other.PixelStore::unpackLsbFirst = GL_TRUE; |
| other.PixelStore::unpackImageHeight = 11; |
| other.PixelStore::unpackSkipImages = 12; |
| other.PixelStore::unpackRowLength = 13; |
| other.PixelStore::unpackSkipRows = 14; |
| other.PixelStore::unpackSkipPixels = 15; |
| other.PixelStore::unpackAlignment = 16; |
| other.PixelStore::packSwapBytes = GL_TRUE; |
| other.PixelStore::packLsbFirst = GL_TRUE; |
| other.PixelStore::packImageHeight = 27; |
| other.PixelStore::packSkipImages = 28; |
| other.PixelStore::packRowLength = 29; |
| other.PixelStore::packSkipRows = 30; |
| other.PixelStore::packSkipPixels = 31; |
| other.PixelStore::packAlignment = 32; |
| other.PixelStore::pixelUnpackBufferBinding = 123; |
| other.PixelStore::pixelPackBufferBinding = 456; |
| |
| // Peform a swap then check these values are now in state |
| |
| other.PixelStore::swap( state ); |
| |
| EXPECT_EQ( GLboolean(GL_TRUE), state.PixelStore::unpackSwapBytes ); |
| EXPECT_EQ( GLboolean(GL_TRUE), state.PixelStore::unpackLsbFirst ); |
| EXPECT_EQ( GLint(11), state.PixelStore::unpackImageHeight ); |
| EXPECT_EQ( GLint(12), state.PixelStore::unpackSkipImages ); |
| EXPECT_EQ( GLint(13), state.PixelStore::unpackRowLength ); |
| EXPECT_EQ( GLint(14), state.PixelStore::unpackSkipRows ); |
| EXPECT_EQ( GLint(15), state.PixelStore::unpackSkipPixels ); |
| EXPECT_EQ( GLint(16), state.PixelStore::unpackAlignment ); |
| EXPECT_EQ( GLboolean(GL_TRUE), state.PixelStore::packSwapBytes ); |
| EXPECT_EQ( GLboolean(GL_TRUE), state.PixelStore::packLsbFirst ); |
| EXPECT_EQ( GLint(27), state.PixelStore::packImageHeight ); |
| EXPECT_EQ( GLint(28), state.PixelStore::packSkipImages ); |
| EXPECT_EQ( GLint(29), state.PixelStore::packRowLength ); |
| EXPECT_EQ( GLint(30), state.PixelStore::packSkipRows ); |
| EXPECT_EQ( GLint(31), state.PixelStore::packSkipPixels ); |
| EXPECT_EQ( GLint(32), state.PixelStore::packAlignment ); |
| EXPECT_EQ( GLuint(123), state.PixelStore::pixelUnpackBufferBinding ); |
| EXPECT_EQ( GLuint(456), state.PixelStore::pixelPackBufferBinding ); |
| |
| // Verify other contains all default values from state |
| |
| checkPixelStoreDefaults(other); |
| } |
| |
| TEST ( RegalPpca, PixelStore_PushPop ) |
| { |
| RegalGMockInterface mock; |
| |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| InitDispatchTableGMock( ctx.dispatcher.emulation ); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| EXPECT_EQ( GLint(4), ppca.PixelStore::unpackAlignment ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(0), ppca.pixelStoreStack.size() ); |
| |
| ppca.glPixelStore( GL_UNPACK_ALIGNMENT, 100 ); |
| ppca.glPushClientAttrib( ctx, 0 ); |
| |
| EXPECT_EQ( GLint(100), ppca.PixelStore::unpackAlignment ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(0), ppca.pixelStoreStack.size() ); |
| |
| ppca.glPixelStore( GL_UNPACK_ALIGNMENT, 101 ); |
| ppca.glPushClientAttrib( ctx, GL_CLIENT_PIXEL_STORE_BIT ); |
| |
| EXPECT_EQ( GLint(101), ppca.PixelStore::unpackAlignment ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(1), ppca.pixelStoreStack.size() ); |
| |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ppca.glClientAttribDefaultEXT( ctx, GL_CLIENT_PIXEL_STORE_BIT ); |
| |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLint(4), ppca.PixelStore::unpackAlignment ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(1), ppca.pixelStoreStack.size() ); |
| |
| ppca.glPixelStore( GL_UNPACK_ALIGNMENT, 102 ); |
| |
| EXPECT_EQ( GLint(102), ppca.PixelStore::unpackAlignment ); |
| |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ppca.glPushClientAttribDefaultEXT( ctx, GL_CLIENT_PIXEL_STORE_BIT ); |
| |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLint(4), ppca.PixelStore::unpackAlignment ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(2), ppca.pixelStoreStack.size() ); |
| |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ppca.glPopClientAttrib( ctx ); |
| |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLint(102), ppca.PixelStore::unpackAlignment ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(1), ppca.pixelStoreStack.size() ); |
| |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ppca.glPopClientAttrib( ctx ); |
| |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLint(101), ppca.PixelStore::unpackAlignment ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(0), ppca.pixelStoreStack.size() ); |
| |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ppca.glPopClientAttrib( ctx ); |
| |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLint(101), ppca.PixelStore::unpackAlignment ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(0), ppca.pixelStoreStack.size() ); |
| |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ppca.glPopClientAttrib( ctx ); |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLint(101), ppca.PixelStore::unpackAlignment ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(0), ppca.pixelStoreStack.size() ); |
| } |
| |
| TEST ( RegalPpca, VertexArray_PushPop ) |
| { |
| RegalGMockInterface mock; |
| |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| ctx.info = new ContextInfo(); |
| InitDispatchTableGMock( ctx.dispatcher.emulation ); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(0), ppca.vertexArrayStack.size() ); |
| |
| ppca.glColorPointer ( 4, GL_FLOAT, 100, NULL ); |
| ppca.glPushClientAttrib( ctx, 0 ); |
| |
| EXPECT_EQ( GLint( 100 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(0), ppca.vertexArrayStack.size() ); |
| |
| ppca.glColorPointer ( 4, GL_FLOAT, 101, NULL ); |
| ppca.glPushClientAttrib( ctx, GL_CLIENT_VERTEX_ARRAY_BIT ); |
| |
| EXPECT_EQ( GLint( 101 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(1), ppca.vertexArrayStack.size() ); |
| |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ppca.glClientAttribDefaultEXT( ctx, GL_CLIENT_VERTEX_ARRAY_BIT ); |
| |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(1), ppca.vertexArrayStack.size() ); |
| |
| ppca.glColorPointer ( 4, GL_FLOAT, 102, NULL ); |
| |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ppca.glPushClientAttribDefaultEXT( ctx, GL_CLIENT_VERTEX_ARRAY_BIT ); |
| |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(2), ppca.vertexArrayStack.size() ); |
| |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ppca.glPopClientAttrib( ctx ); |
| |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLint( 102 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(1), ppca.vertexArrayStack.size() ); |
| |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ppca.glPopClientAttrib( ctx ); |
| |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLint( 101 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(0), ppca.vertexArrayStack.size() ); |
| |
| ppca.glPopClientAttrib( ctx ); |
| |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLint( 101 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(0), ppca.vertexArrayStack.size() ); |
| |
| ppca.glPopClientAttrib( ctx ); |
| |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLint( 101 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(0), ppca.vertexArrayStack.size() ); |
| } |
| |
| TEST ( RegalPpca, ClientAttrib_PushPop ) |
| { |
| RegalGMockInterface mock; |
| |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| ctx.info->core = false; |
| ctx.info->es1 = false; |
| ctx.info->es2 = false; |
| InitDispatchTableGMock( ctx.dispatcher.emulation ); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| const GLbitfield remainder = ~( GL_CLIENT_PIXEL_STORE_BIT | GL_CLIENT_VERTEX_ARRAY_BIT ); |
| |
| GLint clientAttribStackDepth = 666; |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv(ctx, GL_CLIENT_ATTRIB_STACK_DEPTH, &clientAttribStackDepth)); |
| EXPECT_EQ( clientAttribStackDepth, GLint(0) ); |
| |
| EXPECT_EQ( std::vector<GLbitfield>::size_type(0), ppca.maskStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(0), ppca.vertexArrayStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(0), ppca.pixelStoreStack.size() ); |
| |
| ppca.glPushClientAttrib( ctx, GL_CLIENT_PIXEL_STORE_BIT ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv(ctx, GL_CLIENT_ATTRIB_STACK_DEPTH, &clientAttribStackDepth)); |
| EXPECT_EQ( clientAttribStackDepth, GLint(1) ); |
| |
| EXPECT_EQ( std::vector<GLbitfield>::size_type(1), ppca.maskStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(0), ppca.vertexArrayStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(1), ppca.pixelStoreStack.size() ); |
| |
| ppca.glPushClientAttrib( ctx, GL_CLIENT_VERTEX_ARRAY_BIT ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv(ctx, GL_CLIENT_ATTRIB_STACK_DEPTH, &clientAttribStackDepth)); |
| EXPECT_EQ( clientAttribStackDepth, GLint(2) ); |
| |
| EXPECT_EQ( std::vector<GLbitfield>::size_type(2), ppca.maskStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(1), ppca.vertexArrayStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(1), ppca.pixelStoreStack.size() ); |
| |
| EXPECT_CALL( mock, glPushClientAttrib( remainder ) ); |
| |
| ppca.glPushClientAttrib( ctx, GL_CLIENT_ALL_ATTRIB_BITS ); |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv(ctx, GL_CLIENT_ATTRIB_STACK_DEPTH, &clientAttribStackDepth)); |
| EXPECT_EQ( clientAttribStackDepth, GLint(3) ); |
| |
| EXPECT_EQ( std::vector<GLbitfield>::size_type(3), ppca.maskStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(2), ppca.vertexArrayStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(2), ppca.pixelStoreStack.size() ); |
| |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ctx.info->es2 = true; |
| ppca.glPushClientAttrib( ctx, GL_CLIENT_ALL_ATTRIB_BITS ); |
| ppca.glPopClientAttrib( ctx ); |
| ctx.info->es2 = false; |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv(ctx, GL_CLIENT_ATTRIB_STACK_DEPTH, &clientAttribStackDepth)); |
| EXPECT_EQ( clientAttribStackDepth, GLint(3) ); |
| |
| EXPECT_EQ( std::vector<GLbitfield>::size_type(3), ppca.maskStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(2), ppca.vertexArrayStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(2), ppca.pixelStoreStack.size() ); |
| |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| EXPECT_CALL( mock, glPopClientAttrib() ); |
| |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ppca.glPopClientAttrib( ctx ); |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv(ctx, GL_CLIENT_ATTRIB_STACK_DEPTH, &clientAttribStackDepth)); |
| EXPECT_EQ( clientAttribStackDepth, GLint(2) ); |
| |
| EXPECT_EQ( std::vector<GLbitfield>::size_type(2), ppca.maskStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(1), ppca.vertexArrayStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(1), ppca.pixelStoreStack.size() ); |
| |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ppca.glPopClientAttrib( ctx ); |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv(ctx, GL_CLIENT_ATTRIB_STACK_DEPTH, &clientAttribStackDepth)); |
| EXPECT_EQ( clientAttribStackDepth, GLint(1) ); |
| |
| EXPECT_EQ( std::vector<GLbitfield>::size_type(1), ppca.maskStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(0), ppca.vertexArrayStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(1), ppca.pixelStoreStack.size() ); |
| |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ppca.glPopClientAttrib( ctx ); |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv(ctx, GL_CLIENT_ATTRIB_STACK_DEPTH, &clientAttribStackDepth)); |
| EXPECT_EQ( clientAttribStackDepth, GLint(0) ); |
| |
| EXPECT_EQ( std::vector<GLbitfield>::size_type(0), ppca.maskStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(0), ppca.vertexArrayStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(0), ppca.pixelStoreStack.size() ); |
| |
| EXPECT_CALL( mock, glClientAttribDefaultEXT( remainder ) ); |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ppca.glClientAttribDefaultEXT( ctx, GL_CLIENT_ALL_ATTRIB_BITS ); |
| |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( std::vector<GLbitfield>::size_type(0), ppca.maskStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(0), ppca.vertexArrayStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(0), ppca.pixelStoreStack.size() ); |
| |
| EXPECT_CALL( mock, glClientAttribDefaultEXT( remainder ) ); |
| EXPECT_CALL( mock, glPushClientAttrib( remainder ) ); |
| EXPECT_CALL( mock, glBindBuffer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glBindVertexBuffer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glClientActiveTexture(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableClientStateiEXT(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glDisableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEdgeFlagPointer(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnable(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableClientState(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glEnableVertexAttribArray(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glFogCoordPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glIndexPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glMultiTexCoordPointerEXT(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glNormalPointer(_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPixelStorei(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex(_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glSecondaryColorPointer(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribBinding(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribFormat(_,_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribIFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexAttribLFormat(_,_,_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexBindingDivisor(_,_) ).Times(AnyNumber()); |
| EXPECT_CALL( mock, glVertexPointer(_,_,_,_) ).Times(AnyNumber()); |
| |
| ppca.glPushClientAttribDefaultEXT( ctx, GL_CLIENT_ALL_ATTRIB_BITS ); |
| |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_EQ( std::vector<GLbitfield>::size_type(1), ppca.maskStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::VertexArray>::size_type(1), ppca.vertexArrayStack.size() ); |
| EXPECT_EQ( std::vector<ClientState::PixelStore>::size_type(1), ppca.pixelStoreStack.size() ); |
| } |
| |
| TEST ( RegalPpca, VertexArray_Named_BasicOperations ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca state; |
| checkPpcaDefaults(ctx, state); |
| |
| // Set unique data for the array source for all attributes. |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| if ( ii == 4 ) { |
| state.VertexArray::named[ii].enabled = GLboolean(GL_TRUE); |
| } else { |
| state.VertexArray::named[ii].enabled = GLboolean(GL_FALSE); |
| } |
| state.VertexArray::named[ii].pointer = reinterpret_cast<const GLvoid*>(ii * 10 + 5); |
| state.VertexArray::named[ii].buffer = GLuint(ii * 10 + 1); |
| state.VertexArray::named[ii].size = GLint( ii * 10 + 2); |
| state.VertexArray::named[ii].type = GLenum(ii * 10 + 3); |
| state.VertexArray::named[ii].stride = GLuint(ii * 10 + 4); |
| } |
| |
| // Calls with out-of-bound values should silently return as a no-op. |
| // This is done here so if we affect the explicitly set state it will be |
| // detected soon. |
| |
| state.glEnableClientState( GLenum(~0) ); |
| state.glEnableClientStateiEXT( GL_TEXTURE_COORD_ARRAY, GLuint(~0) ); |
| |
| state.glDisableClientState( GLenum(~0) ); |
| state.glDisableClientStateiEXT( GL_TEXTURE_COORD_ARRAY, GLuint(~0) ); |
| |
| state.glEnable( GLenum(~0) ); |
| state.glEnable( GLenum(ClientState::nNamedArrays) ); |
| |
| state.glDisable( GLenum(~0) ); |
| state.glDisable( GLenum(ClientState::nNamedArrays) ); |
| |
| // Peform a swap, so that it is effectively tested too |
| |
| Ppca other; |
| checkPpcaDefaults(ctx, other); |
| |
| state.VertexArray::swap( other ); |
| |
| // Verify the expected default state ended up in the original |
| |
| checkPpcaDefaults(ctx, state); |
| |
| // Verify the modified data ended up in the other state |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| if ( ii == 4 ) { |
| EXPECT_EQ( GLboolean(GL_TRUE), other.VertexArray::named[ii].enabled ); |
| } else { |
| EXPECT_EQ( GLboolean(GL_FALSE), other.VertexArray::named[ii].enabled ); |
| } |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>(ii * 10 + 5), other.VertexArray::named[ ii ].pointer ); |
| EXPECT_EQ( GLuint(ii * 10 + 1), other.VertexArray::named[ ii ].buffer ); |
| EXPECT_EQ( GLint( ii * 10 + 2), other.VertexArray::named[ ii ].size ); |
| EXPECT_EQ( GLenum(ii * 10 + 3), other.VertexArray::named[ ii ].type ); |
| EXPECT_EQ( GLuint(ii * 10 + 4), other.VertexArray::named[ ii ].stride ); |
| } |
| } |
| |
| TEST ( RegalPpca, VertexArray_Generic_BasicOperations ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca state; |
| checkPpcaDefaults(ctx, state); |
| |
| // Set unique data for the arrays |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS; ii++) |
| { |
| if ( ii == 4 ) { |
| state.VertexArray::generic[ii].enabled = GLboolean(GL_TRUE); |
| } else { |
| state.VertexArray::generic[ii].enabled = GLboolean(GL_FALSE); |
| } |
| state.VertexArray::generic[ii].size = GLuint(ii * 100 + 1); |
| state.VertexArray::generic[ii].type = GLenum(ii * 100 + 2); |
| state.VertexArray::generic[ii].relativeOffset = GLuint(ii * 100 + 3); |
| state.VertexArray::generic[ii].normalized = GLboolean(ii * 100 + 4); |
| state.VertexArray::generic[ii].isInteger = GLboolean(ii * 100 + 5); |
| state.VertexArray::generic[ii].isLong = GLboolean(ii * 100 + 6); |
| state.VertexArray::generic[ii].bindingIndex = GLuint(ii * 100 + 7); |
| } |
| |
| // Set unique data for the bindings |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| state.VertexArray::bindings[ii].buffer = GLuint(ii * 1000 + 1); |
| state.VertexArray::bindings[ii].offset = GLintptr(ii * 1000 + 2); |
| state.VertexArray::bindings[ii].stride = GLsizei(ii * 1000 + 3); |
| state.VertexArray::bindings[ii].divisor = GLuint(ii * 1000 + 4); |
| } |
| |
| // Calls with out-of-bound values should silently return as a no-op. |
| // This is done here so if we affect the explicitly set state it will be |
| // detected soon. |
| |
| state.glEnableVertexArrayAttribEXT( 0, GLuint(~0) ); |
| state.glDisableVertexArrayAttribEXT( 0, GLuint(~0) ); |
| state.glVertexAttribFormat( GLuint(~0), 0, 0, GL_TRUE, 0 ); |
| state.glVertexAttribFormat( GLuint(~0), 0, 0, GL_FALSE, 0 ); |
| state.glVertexAttribLFormat( GLuint(~0), 0, 0, 0 ); |
| state.glVertexAttribIFormat( GLuint(~0), 0, 0, 0 ); |
| state.glVertexAttribBinding( GLuint(~0), 0 ); |
| state.glEnableVertexAttribArray( GLuint(~0) ); |
| state.glDisableVertexAttribArray( GLuint(~0) ); |
| |
| state.glEnableVertexArrayAttribEXT( 0, REGAL_EMU_MAX_VERTEX_ATTRIBS ); |
| state.glDisableVertexArrayAttribEXT( 0, REGAL_EMU_MAX_VERTEX_ATTRIBS ); |
| state.glVertexAttribFormat( REGAL_EMU_MAX_VERTEX_ATTRIBS, 0, 0, GL_TRUE, 0 ); |
| state.glVertexAttribFormat( REGAL_EMU_MAX_VERTEX_ATTRIBS, 0, 0, GL_FALSE, 0 ); |
| state.glVertexAttribLFormat( REGAL_EMU_MAX_VERTEX_ATTRIBS, 0, 0, 0 ); |
| state.glVertexAttribIFormat( REGAL_EMU_MAX_VERTEX_ATTRIBS, 0, 0, 0 ); |
| state.glVertexAttribBinding( REGAL_EMU_MAX_VERTEX_ATTRIBS, 0 ); |
| state.glEnableVertexAttribArray( REGAL_EMU_MAX_VERTEX_ATTRIBS ); |
| state.glDisableVertexAttribArray( REGAL_EMU_MAX_VERTEX_ATTRIBS ); |
| |
| state.glVertexAttribDivisor( GLuint(~0), 0 ); |
| state.glVertexBindingDivisor( GLuint(~0), 0 ); |
| state.glBindVertexBuffers( GLuint(~0), 0, 0, 0, 0); |
| state.glBindVertexBuffers( GLuint(~0), 0, (const GLuint*)(0xdead), 0, 0); |
| state.glBindVertexBuffers( 0, GLuint(~0), 0, 0, 0); |
| state.glBindVertexBuffers( 0, GLuint(~0), (const GLuint*)(0xdead), 0, 0); |
| |
| state.glBindVertexBuffer( GLuint(GLuint(~0) - 1), 0, 0, 0); |
| state.glBindVertexBuffer( GLuint(~0), 0, 0, 0); |
| |
| state.glVertexArrayMultiTexCoordOffsetEXT(0, 0, GLenum(~0), 0, GLenum(0), 0, GLintptr(0) ); |
| |
| state.glVertexAttribDivisor( REGAL_EMU_MAX_VERTEX_ATTRIBS, 0 ); |
| state.glVertexAttribDivisor( REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS, 0 ); |
| state.glVertexBindingDivisor( REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS, 0 ); |
| state.glBindVertexBuffers( REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS, 0, 0, 0, 0); |
| state.glBindVertexBuffers( REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS, 0, (const GLuint*)(0xdead), 0, 0); |
| |
| // don't change this 1 to a 0. if you do, among other things glBindVertexBuffer will try to access |
| // the bogus pointers being passed in here and you get what you deserve. |
| |
| state.glBindVertexBuffers( 1, REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS, 0, 0, 0); |
| state.glBindVertexBuffers( 1, REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS, (const GLuint*)(0xdead), 0, 0); |
| |
| state.glBindVertexBuffer( REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS, 0, 0, 0); |
| |
| // Peform a swap, so that it is effectively tested too |
| |
| Ppca other; |
| checkPpcaDefaults(ctx, other); |
| |
| state.VertexArray::swap( other ); |
| |
| // Verify the expected default state ended up in the original |
| |
| checkPpcaDefaults(ctx, state); |
| |
| // Verify the modified array data ended up in the other state |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS; ii++) |
| { |
| if ( ii == 4 ) { |
| EXPECT_EQ( GLboolean(GL_TRUE), other.VertexArray::generic[ ii ].enabled ); |
| } else { |
| EXPECT_EQ( GLboolean(GL_FALSE), other.VertexArray::generic[ ii ].enabled ); |
| } |
| EXPECT_EQ( GLuint(ii * 100 + 1), other.VertexArray::generic[ ii ].size ); |
| EXPECT_EQ( GLenum(ii * 100 + 2), other.VertexArray::generic[ ii ].type ); |
| EXPECT_EQ( GLuint(ii * 100 + 3), other.VertexArray::generic[ ii ].relativeOffset ); |
| EXPECT_EQ( GLboolean(ii * 100 + 4), other.VertexArray::generic[ ii ].normalized ); |
| EXPECT_EQ( GLboolean(ii * 100 + 5), other.VertexArray::generic[ ii ].isInteger ); |
| EXPECT_EQ( GLboolean(ii * 100 + 6), other.VertexArray::generic[ ii ].isLong ); |
| EXPECT_EQ( GLuint(ii * 100 + 7), other.VertexArray::generic[ ii ].bindingIndex ); |
| } |
| |
| // Verify the modified bindings data ended up in the other state |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| EXPECT_EQ( GLuint(ii * 1000 + 1), other.VertexArray::bindings[ ii ].buffer ); |
| EXPECT_EQ( GLintptr( ii * 1000 + 2), other.VertexArray::bindings[ ii ].offset ); |
| EXPECT_EQ( GLsizei(ii * 1000 + 3), other.VertexArray::bindings[ ii ].stride ); |
| EXPECT_EQ( GLuint(ii * 1000 + 4), other.VertexArray::bindings[ ii ].divisor ); |
| } |
| } |
| |
| TEST ( RegalPpca, VertexArrayGenericState_Transition ) |
| { |
| RegalGMockInterface mock; |
| |
| DispatchTableGL dt; |
| ::memset(&dt,0,sizeof(DispatchTableGL)); |
| dt._enabled = true; |
| InitDispatchTableGMock( dt ); |
| |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca current; |
| checkPpcaDefaults(ctx, current); |
| |
| Ppca target; |
| checkPpcaDefaults(ctx, target); |
| |
| // An attribute array can be enabled. |
| |
| target.glEnableVertexAttribArray( 0 ); |
| |
| EXPECT_CALL( mock, glEnableVertexAttribArray( 0 ) ); |
| |
| // An attribute array can be configured. |
| |
| target.glVertexAttribFormat ( 1, 11, GLenum(12), GL_FALSE, 13 ); |
| target.glVertexAttribFormat ( 2, 21, GLenum(22), GL_TRUE, 23 ); |
| target.glVertexAttribIFormat( 3, 31, GLenum(32), 33 ); |
| |
| EXPECT_CALL( mock, glVertexAttribFormat ( 1, 11, 12, GL_FALSE, 13 ) ); |
| EXPECT_CALL( mock, glVertexAttribFormat ( 2, 21, 22, GL_TRUE, 23 ) ); |
| EXPECT_CALL( mock, glVertexAttribIFormat( 3, 31, 32, 33 ) ); |
| |
| // An attribute buffer can be configured. |
| |
| target.glBindVertexBuffer( 4, 41, 42, 43 ); |
| |
| EXPECT_CALL( mock, glBindVertexBuffer( 4, 41, 42, 43 ) ); |
| |
| // An attribute buffer divisor can be configured. |
| |
| target.glVertexBindingDivisor( 5, 51 ); |
| EXPECT_CALL( mock, glVertexBindingDivisor( 5, 51 ) ); |
| |
| target.glVertexAttribBinding( 6, 7 ); |
| EXPECT_CALL( mock, glVertexAttribBinding( 6, 7 ) ); |
| |
| target.glEnableVertexAttribArray( 8 ); |
| |
| EXPECT_CALL( mock, glEnableVertexAttribArray ( 8 ) ); |
| |
| // transition, verify, and reset |
| |
| current.VertexArray::transition( dt, target, true ); |
| Mock::VerifyAndClear( &mock ); |
| |
| // An attribute can be disabled and all data reset to default. |
| |
| target.glDisableVertexAttribArray( 8 ); |
| target.glVertexAttribFormat( 8, 61, 62, GL_FALSE, 63 ); |
| target.glBindVertexBuffer( 8, 64, 65, 66 ); |
| target.glVertexBindingDivisor( 8, 67 ); |
| target.glVertexAttribBinding( 8, 9 ); |
| |
| EXPECT_CALL( mock, glDisableVertexAttribArray ( 8 ) ); |
| EXPECT_CALL( mock, glVertexAttribFormat ( 8, 61, 62, GL_FALSE, 63 ) ); |
| EXPECT_CALL( mock, glBindVertexBuffer( 8, 64, 65, 66 ) ); |
| EXPECT_CALL( mock, glVertexBindingDivisor( 8, 67 ) ); |
| EXPECT_CALL( mock, glVertexAttribBinding( 8, 9 ) ); |
| |
| // transition, verify, and reset |
| |
| current.VertexArray::transition( dt, target, true ); |
| Mock::VerifyAndClear( &mock ); |
| |
| // Identical state is a no-op in terms of calls. |
| |
| current.VertexArray::transition( dt, target, true ); |
| Mock::VerifyAndClear( &mock ); |
| |
| current.VertexArray::transition( dt, current, true ); |
| Mock::VerifyAndClear( &mock ); |
| |
| target.VertexArray::transition( dt, target, true ); |
| Mock::VerifyAndClear( &mock ); |
| |
| target.Reset(ctx); |
| current.Reset(ctx); |
| |
| target.glEnableVertexAttribArray( 0 ); |
| target.glVertexAttribFormat ( 0, 11, GLenum(12), GL_FALSE, 13 ); |
| target.glBindVertexBuffer( 0, 14, 15, 16 ); |
| target.glVertexBindingDivisor( 0, 17 ); |
| target.glVertexAttribBinding( 0, 1 ); |
| |
| current.glEnableVertexAttribArray( 0 ); |
| current.glVertexAttribFormat ( 0, 11, GLenum(12), GL_FALSE, 13 ); |
| current.glBindVertexBuffer( 0, 14, 15, 16 ); |
| current.glVertexBindingDivisor( 0, 17 ); |
| current.glVertexAttribBinding( 0, 1 ); |
| |
| current.VertexArray::transition( dt, target, true ); |
| Mock::VerifyAndClear( &mock ); |
| } |
| |
| TEST ( RegalPpca, VertexArray_Transition ) |
| { |
| RegalGMockInterface mock; |
| |
| DispatchTableGL dt; |
| ::memset(&dt,0,sizeof(DispatchTableGL)); |
| dt._enabled = true; |
| InitDispatchTableGMock( dt ); |
| |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca current; |
| checkPpcaDefaults(ctx, current); |
| |
| Ppca target; |
| checkPpcaDefaults(ctx, target); |
| |
| // Set up a simple non-default state, focusing on state unique this structure. |
| |
| target.elementArrayBufferBinding = GLuint(1); |
| target.clientActiveTexture = GLenum(2); |
| target.primitiveRestartFixedIndex = GLboolean(GL_TRUE); |
| target.primitiveRestart = GLboolean(GL_TRUE); |
| target.primitiveRestartIndex = GLuint(3); |
| target.arrayBufferBinding = GLuint(4); |
| target.vertexArrayBinding = GLuint(5); |
| |
| // Set up expectations. |
| |
| EXPECT_CALL( mock, glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 1 ) ); |
| EXPECT_CALL( mock, glClientActiveTexture( 2 ) ); |
| EXPECT_CALL( mock, glEnable( GL_PRIMITIVE_RESTART_FIXED_INDEX ) ); |
| EXPECT_CALL( mock, glEnable( GL_PRIMITIVE_RESTART ) ); |
| EXPECT_CALL( mock, glPrimitiveRestartIndex( 3 ) ); |
| EXPECT_CALL( mock, glBindBuffer( GL_ARRAY_BUFFER, 4 ) ); |
| EXPECT_CALL( mock, glBindVertexArray( 5 ) ); |
| |
| // Perform the requested state transition. |
| |
| current.VertexArray::transition( dt, target, true ); |
| |
| // Verify the call expectations, and reset for another test. |
| |
| Mock::VerifyAndClear( &mock ); |
| |
| // unfortunately even though this call to transition() won't actually |
| // do anything, the current implementation will clear the bound vertex |
| // array, do the changes (which turns out to be none), then bind back |
| // to the original vertex array |
| |
| EXPECT_CALL( mock, glBindVertexArray( 0 ) ); |
| EXPECT_CALL( mock, glBindVertexArray( 5 ) ); |
| |
| // Perform the requested state transition. |
| |
| current.VertexArray::transition( dt, target, true ); |
| |
| // Verify the call expectations, and reset for another test. |
| |
| Mock::VerifyAndClear( &mock ); |
| |
| // A transition with no differences should make no calls, but... |
| // see above comment. |
| |
| EXPECT_CALL( mock, glBindVertexArray( 0 ) ); |
| EXPECT_CALL( mock, glBindVertexArray( 5 ) ); |
| |
| current.VertexArray::transition( dt, current, true ); |
| Mock::VerifyAndClear( &mock ); |
| |
| EXPECT_CALL( mock, glBindVertexArray( 0 ) ); |
| EXPECT_CALL( mock, glBindVertexArray( 5 ) ); |
| |
| target.VertexArray::transition( dt, target, true ); |
| Mock::VerifyAndClear( &mock ); |
| |
| current.Reset(ctx); |
| target.Reset(ctx); |
| |
| // Now there really won't be any calls since both the |
| // current and target vertex array to bind is 0 |
| |
| current.VertexArray::transition( dt, target, true ); |
| Mock::VerifyAndClear( &mock ); |
| |
| // set some state other than the vertex array binding |
| |
| target.elementArrayBufferBinding = GLuint(1); |
| target.clientActiveTexture = GLenum(2); |
| target.primitiveRestartFixedIndex = GLboolean(GL_TRUE); |
| target.primitiveRestart = GLboolean(GL_TRUE); |
| target.primitiveRestartIndex = GLuint(3); |
| target.arrayBufferBinding = GLuint(4); |
| |
| current.elementArrayBufferBinding = GLuint(1); |
| current.clientActiveTexture = GLenum(2); |
| current.primitiveRestartFixedIndex = GLboolean(GL_TRUE); |
| current.primitiveRestart = GLboolean(GL_TRUE); |
| current.primitiveRestartIndex = GLuint(3); |
| current.arrayBufferBinding = GLuint(4); |
| |
| // and again no calls. |
| |
| current.VertexArray::transition( dt, target, true ); |
| Mock::VerifyAndClear( &mock ); |
| } |
| |
| TEST ( RegalPpca, PixelStore_Transition ) |
| { |
| RegalGMockInterface mock; |
| |
| DispatchTableGL dt; |
| ::memset(&dt,0,sizeof(DispatchTableGL)); |
| dt._enabled = true; |
| InitDispatchTableGMock( dt ); |
| |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca current; |
| checkPpcaDefaults(ctx, current); |
| |
| Ppca target; |
| checkPpcaDefaults(ctx, target); |
| |
| // Set some of the named attributes, and expect that calls will be made |
| // appropriately to the backend to transition to those value. |
| |
| current.PixelStore::unpackSkipPixels = GLuint(123); |
| current.PixelStore::unpackAlignment = GLuint(456); |
| |
| target.PixelStore::pixelPackBufferBinding = GLuint(321); |
| target.PixelStore::pixelUnpackBufferBinding = GLuint(654); |
| |
| EXPECT_CALL( mock, glPixelStorei( GL_UNPACK_SKIP_PIXELS , 0 ) ); |
| EXPECT_CALL( mock, glPixelStorei( GL_UNPACK_ALIGNMENT , 4 ) ); |
| EXPECT_CALL( mock, glBindBuffer ( GL_PIXEL_PACK_BUFFER , 321 ) ); |
| EXPECT_CALL( mock, glBindBuffer ( GL_PIXEL_UNPACK_BUFFER, 654 ) ); |
| |
| // Perform the state transition and verify expectations |
| |
| current.PixelStore::transition( dt, target ); |
| Mock::VerifyAndClear( &mock ); |
| |
| // A transition with no differences should make no calls. |
| |
| current.PixelStore::transition( dt, current ); |
| Mock::VerifyAndClear( &mock ); |
| |
| target.PixelStore::transition( dt, target ); |
| Mock::VerifyAndClear( &mock ); |
| |
| current.Reset(ctx); |
| target.Reset(ctx); |
| |
| current.PixelStore::transition( dt, target ); |
| Mock::VerifyAndClear( &mock ); |
| |
| target.PixelStore::unpackSkipPixels = GLuint(123); |
| target.PixelStore::unpackAlignment = GLuint(456); |
| target.PixelStore::pixelPackBufferBinding = GLuint(321); |
| target.PixelStore::pixelUnpackBufferBinding = GLuint(654); |
| |
| current.PixelStore::unpackSkipPixels = GLuint(123); |
| current.PixelStore::unpackAlignment = GLuint(456); |
| current.PixelStore::pixelPackBufferBinding = GLuint(321); |
| current.PixelStore::pixelUnpackBufferBinding = GLuint(654); |
| |
| current.PixelStore::transition( dt, target ); |
| Mock::VerifyAndClear( &mock ); |
| } |
| |
| TEST ( RegalPpca, VertexArray_Generic ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // VertexAttribFormat |
| |
| ppca.glVertexAttribFormat ( 3, 4, GL_FLOAT, GL_TRUE, 123 ); |
| |
| EXPECT_EQ( GLuint(4), ppca.VertexArray::generic[3].size ); |
| EXPECT_EQ( GLenum(GL_FLOAT), ppca.VertexArray::generic[3].type ); |
| EXPECT_EQ( GLuint(123), ppca.VertexArray::generic[3].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[3].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isLong ); |
| |
| ppca.Reset(ctx); |
| ppca.glVertexAttribFormat ( 3, 4, GL_FLOAT, GL_FALSE, 123 ); |
| |
| EXPECT_EQ( GLuint(4), ppca.VertexArray::generic[3].size ); |
| EXPECT_EQ( GLenum(GL_FLOAT), ppca.VertexArray::generic[3].type ); |
| EXPECT_EQ( GLuint(123), ppca.VertexArray::generic[3].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isLong ); |
| |
| ppca.Reset(ctx); |
| ppca.glVertexAttribIFormat( 3, 1, GL_INT, 456 ); |
| |
| EXPECT_EQ( GLuint(1), ppca.VertexArray::generic[3].size ); |
| EXPECT_EQ( GLenum(GL_INT), ppca.VertexArray::generic[3].type ); |
| EXPECT_EQ( GLuint(456), ppca.VertexArray::generic[3].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[3].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isLong ); |
| |
| ppca.Reset(ctx); |
| ppca.glVertexAttribLFormat( 3, 2, GL_DOUBLE, 789 ); |
| |
| EXPECT_EQ( GLuint(2), ppca.VertexArray::generic[3].size ); |
| EXPECT_EQ( GLenum(GL_DOUBLE), ppca.VertexArray::generic[3].type ); |
| EXPECT_EQ( GLuint(789), ppca.VertexArray::generic[3].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isInteger ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[3].isLong ); |
| |
| // BindVertexBuffer |
| |
| ppca.Reset(ctx); |
| ppca.glBindVertexBuffer( 4, 5, 6, 7 ); |
| |
| EXPECT_EQ( GLuint(5), ppca.VertexArray::bindings[4].buffer ); |
| EXPECT_EQ( GLintptr(6), ppca.VertexArray::bindings[4].offset ); |
| EXPECT_EQ( GLsizei(7), ppca.VertexArray::bindings[4].stride ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::bindings[4].divisor ); |
| |
| // VertexAttribBinding |
| |
| ppca.Reset(ctx); |
| ppca.glVertexAttribBinding( 3, 4 ); |
| |
| EXPECT_EQ( GLuint(4), ppca.VertexArray::generic[3].bindingIndex ); |
| |
| // VertexAttribPointer |
| |
| ppca.Reset(ctx); |
| ppca.VertexArray::arrayBufferBinding = 8888; |
| ppca.glVertexAttribPointer ( 3, 1, GL_FLOAT, GL_TRUE, 123, reinterpret_cast<const GLvoid *>( 321 ) ); |
| |
| EXPECT_EQ( GLuint(1), ppca.VertexArray::generic[3].size ); |
| EXPECT_EQ( GLenum(GL_FLOAT), ppca.VertexArray::generic[3].type ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::generic[3].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[3].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isLong ); |
| EXPECT_EQ( GLuint(3), ppca.VertexArray::generic[3].bindingIndex ); |
| |
| EXPECT_EQ( GLuint(8888), ppca.VertexArray::bindings[3].buffer ); |
| EXPECT_EQ( GLintptr(321), ppca.VertexArray::bindings[3].offset ); |
| EXPECT_EQ( GLsizei(123), ppca.VertexArray::bindings[3].stride ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::bindings[3].divisor ); |
| |
| ppca.Reset(ctx); |
| ppca.VertexArray::arrayBufferBinding = 8888; |
| ppca.glVertexAttribPointer ( 3, 1, GL_FLOAT, GL_FALSE, 0, reinterpret_cast<GLvoid *>( 321 ) ); |
| |
| EXPECT_EQ( GLuint(1), ppca.VertexArray::generic[3].size ); |
| EXPECT_EQ( GLenum(GL_FLOAT), ppca.VertexArray::generic[3].type ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::generic[3].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isLong ); |
| EXPECT_EQ( GLuint(3), ppca.VertexArray::generic[3].bindingIndex ); |
| |
| EXPECT_EQ( GLuint(8888), ppca.VertexArray::bindings[3].buffer ); |
| EXPECT_EQ( GLintptr(321), ppca.VertexArray::bindings[3].offset ); |
| EXPECT_EQ( GLsizei(4), ppca.VertexArray::bindings[3].stride ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::bindings[3].divisor ); |
| |
| ppca.Reset(ctx); |
| ppca.VertexArray::arrayBufferBinding = 8888; |
| ppca.glVertexAttribIPointer ( 3, 2, GL_INT, 456, reinterpret_cast<GLvoid *>( 654 ) ); |
| |
| EXPECT_EQ( GLuint(2), ppca.VertexArray::generic[3].size ); |
| EXPECT_EQ( GLenum(GL_INT), ppca.VertexArray::generic[3].type ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::generic[3].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[3].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isLong ); |
| EXPECT_EQ( GLuint(3), ppca.VertexArray::generic[3].bindingIndex ); |
| |
| EXPECT_EQ( GLuint(8888), ppca.VertexArray::bindings[3].buffer ); |
| EXPECT_EQ( GLintptr(654), ppca.VertexArray::bindings[3].offset ); |
| EXPECT_EQ( GLsizei(456), ppca.VertexArray::bindings[3].stride ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::bindings[3].divisor ); |
| |
| ppca.Reset(ctx); |
| ppca.VertexArray::arrayBufferBinding = 8888; |
| ppca.glVertexAttribIPointer( 3, 2, GL_INT, 0, reinterpret_cast<GLvoid *>( 654 ) ); |
| |
| EXPECT_EQ( GLuint(2), ppca.VertexArray::generic[3].size ); |
| EXPECT_EQ( GLenum(GL_INT), ppca.VertexArray::generic[3].type ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::generic[3].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[3].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isLong ); |
| EXPECT_EQ( GLuint(3), ppca.VertexArray::generic[3].bindingIndex ); |
| |
| EXPECT_EQ( GLuint(8888), ppca.VertexArray::bindings[3].buffer ); |
| EXPECT_EQ( GLintptr(654), ppca.VertexArray::bindings[3].offset ); |
| EXPECT_EQ( GLsizei(8), ppca.VertexArray::bindings[3].stride ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::bindings[3].divisor ); |
| |
| ppca.Reset(ctx); |
| ppca.VertexArray::arrayBufferBinding = 8888; |
| ppca.glVertexAttribLPointer( 3, 3, GL_DOUBLE, 789, reinterpret_cast<GLvoid *>( 987 ) ); |
| |
| EXPECT_EQ( GLuint(3), ppca.VertexArray::generic[3].size ); |
| EXPECT_EQ( GLenum(GL_DOUBLE), ppca.VertexArray::generic[3].type ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::generic[3].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isInteger ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[3].isLong ); |
| EXPECT_EQ( GLuint(3), ppca.VertexArray::generic[3].bindingIndex ); |
| |
| EXPECT_EQ( GLuint(8888), ppca.VertexArray::bindings[3].buffer ); |
| EXPECT_EQ( GLintptr(987), ppca.VertexArray::bindings[3].offset ); |
| EXPECT_EQ( GLsizei(789), ppca.VertexArray::bindings[3].stride ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::bindings[3].divisor ); |
| |
| ppca.VertexArray::arrayBufferBinding = 8888; |
| ppca.glVertexAttribLPointer( 3, 3, GL_DOUBLE, 0, reinterpret_cast<GLvoid *>( 987 ) ); |
| |
| EXPECT_EQ( GLuint(3), ppca.VertexArray::generic[3].size ); |
| EXPECT_EQ( GLenum(GL_DOUBLE), ppca.VertexArray::generic[3].type ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::generic[3].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isInteger ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[3].isLong ); |
| EXPECT_EQ( GLuint(3), ppca.VertexArray::generic[3].bindingIndex ); |
| |
| EXPECT_EQ( GLuint(8888), ppca.VertexArray::bindings[3].buffer ); |
| EXPECT_EQ( GLintptr(987), ppca.VertexArray::bindings[3].offset ); |
| EXPECT_EQ( GLsizei(24), ppca.VertexArray::bindings[3].stride ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::bindings[3].divisor ); |
| |
| // Enable/DisableVertexAttribArray |
| |
| ppca.Reset(ctx); |
| ppca.glEnableVertexAttribArray( 3 ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::generic[ 3 ].enabled ); |
| |
| ppca.glDisableVertexAttribArray( 3 ); |
| |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::generic[ 3 ].enabled ); |
| |
| // VertexBindingDivisor |
| |
| ppca.Reset(ctx); |
| ppca.glVertexBindingDivisor( 4, 123 ); |
| |
| EXPECT_EQ( GLuint(123), ppca.VertexArray::bindings[4].divisor ); |
| |
| // VertexAttribDivisor |
| |
| ppca.Reset(ctx); |
| ppca.glVertexAttribDivisor( 3, 456 ); |
| |
| EXPECT_EQ( GLuint(3), ppca.VertexArray::generic[3].bindingIndex ); |
| EXPECT_EQ( GLuint(456), ppca.VertexArray::bindings[3].divisor ); |
| |
| // ShadowVertexArrayVertexAttribOffsetEXT |
| |
| ppca.Reset(ctx); |
| ppca.glVertexArrayVertexAttribOffsetEXT( 0, 987, 3, 1, GL_FLOAT, GL_TRUE, 123, 321 ); |
| |
| EXPECT_EQ( GLuint(1), ppca.VertexArray::generic[3].size ); |
| EXPECT_EQ( GLenum(GL_FLOAT), ppca.VertexArray::generic[3].type ); |
| EXPECT_EQ( GLuint( 0 ), ppca.VertexArray::generic[3].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[3].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isLong ); |
| EXPECT_EQ( GLuint(3), ppca.VertexArray::generic[3].bindingIndex ); |
| |
| EXPECT_EQ( GLuint(987), ppca.VertexArray::bindings[3].buffer ); |
| EXPECT_EQ( GLintptr(321), ppca.VertexArray::bindings[3].offset ); |
| EXPECT_EQ( GLsizei(123), ppca.VertexArray::bindings[3].stride ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::bindings[3].divisor ); |
| |
| ppca.Reset(ctx); |
| ppca.glVertexArrayVertexAttribOffsetEXT( 0, 987, 3, 1, GL_FLOAT, GL_FALSE, 0, 321 ); |
| |
| EXPECT_EQ( GLuint(1), ppca.VertexArray::generic[3].size ); |
| EXPECT_EQ( GLenum(GL_FLOAT), ppca.VertexArray::generic[3].type ); |
| EXPECT_EQ( GLuint( 0 ), ppca.VertexArray::generic[3].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isLong ); |
| EXPECT_EQ( GLuint(3), ppca.VertexArray::generic[3].bindingIndex ); |
| |
| EXPECT_EQ( GLuint(987), ppca.VertexArray::bindings[3].buffer ); |
| EXPECT_EQ( GLintptr(321), ppca.VertexArray::bindings[3].offset ); |
| EXPECT_EQ( GLsizei(4), ppca.VertexArray::bindings[3].stride ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::bindings[3].divisor ); |
| |
| ppca.Reset(ctx); |
| ppca.glVertexArrayVertexAttribIOffsetEXT( 0, 987, 3, 2, GL_INT, 456, 654 ); |
| |
| EXPECT_EQ( GLuint(2), ppca.VertexArray::generic[3].size ); |
| EXPECT_EQ( GLenum(GL_INT), ppca.VertexArray::generic[3].type ); |
| EXPECT_EQ( GLuint( 0 ), ppca.VertexArray::generic[3].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[3].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isLong ); |
| EXPECT_EQ( GLuint(3), ppca.VertexArray::generic[3].bindingIndex ); |
| |
| EXPECT_EQ( GLuint(987), ppca.VertexArray::bindings[3].buffer ); |
| EXPECT_EQ( GLintptr(654), ppca.VertexArray::bindings[3].offset ); |
| EXPECT_EQ( GLsizei(456), ppca.VertexArray::bindings[3].stride ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::bindings[3].divisor ); |
| |
| ppca.Reset(ctx); |
| ppca.glVertexArrayVertexAttribIOffsetEXT( 0, 987, 3, 2, GL_INT, 0, 654 ); |
| |
| EXPECT_EQ( GLuint(2), ppca.VertexArray::generic[3].size ); |
| EXPECT_EQ( GLenum(GL_INT), ppca.VertexArray::generic[3].type ); |
| EXPECT_EQ( GLuint( 0 ), ppca.VertexArray::generic[3].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[3].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[3].isLong ); |
| EXPECT_EQ( GLuint(3), ppca.VertexArray::generic[3].bindingIndex ); |
| |
| EXPECT_EQ( GLuint(987), ppca.VertexArray::bindings[3].buffer ); |
| EXPECT_EQ( GLintptr(654), ppca.VertexArray::bindings[3].offset ); |
| EXPECT_EQ( GLsizei(8), ppca.VertexArray::bindings[3].stride ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::bindings[3].divisor ); |
| |
| // EnableDisableVertexArrayAttribEXT |
| |
| ppca.Reset(ctx); |
| ppca.glEnableVertexArrayAttribEXT( 0, 3 ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::generic [ 3 ].enabled ); |
| |
| ppca.glDisableVertexArrayAttribEXT( 0, 3 ); |
| |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::generic [ 3 ].enabled ); |
| |
| // If the vertex array binding is nonzero, none of these calls should do |
| // anything (since we do not actually track internal state for vertex array |
| // objects. |
| |
| ppca.Reset(ctx); |
| ppca.VertexArray::generic[ 3 ].relativeOffset = GLuint(123); |
| ppca.VertexArray::generic[ 3 ].bindingIndex = 4; |
| ppca.VertexArray::bindings[ 4 ].buffer = 456; |
| ppca.VertexArray::bindings[ 4 ].divisor = 789; |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| |
| ppca.glVertexAttribFormat ( 3, 3, GL_FLOAT, GL_TRUE, 0 ); |
| ppca.glVertexAttribIFormat( 3, 3, GL_INT, 0 ); |
| ppca.glVertexAttribLFormat( 3, 3, GL_DOUBLE, 0 ); |
| ppca.glBindVertexBuffer( 4, 0, 0, 0 ); |
| ppca.glVertexAttribBinding( 3, 0 ); |
| ppca.glVertexAttribPointer ( 3, 1, GL_FLOAT, GL_TRUE, 0, NULL ); |
| ppca.glVertexAttribIPointer( 3, 2, GL_INT, 0, NULL ); |
| ppca.glVertexAttribLPointer( 3, 3, GL_DOUBLE, 0, NULL ); |
| ppca.glVertexBindingDivisor( 4, 0 ); |
| ppca.glVertexArrayVertexAttribOffsetEXT ( 1, 0, 3, 1, GL_FLOAT, GL_TRUE, 0, 0 ); |
| ppca.glVertexArrayVertexAttribIOffsetEXT( 1, 0, 3, 2, GL_INT, 0, 0 ); |
| |
| EXPECT_EQ( GLuint(123), ppca.VertexArray::generic[3].relativeOffset ); |
| EXPECT_EQ( GLuint(4), ppca.VertexArray::generic[3].bindingIndex ); |
| EXPECT_EQ( GLuint(456), ppca.VertexArray::bindings[4].buffer ); |
| EXPECT_EQ( GLuint(789), ppca.VertexArray::bindings[4].divisor ); |
| |
| ppca.VertexArray::generic [ 3 ].enabled = GL_FALSE; |
| ppca.glEnableVertexAttribArray( 3 ); |
| ppca.glEnableVertexArrayAttribEXT( 1, 3 ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::generic [ 3 ].enabled ); |
| |
| ppca.VertexArray::generic [ 3 ].enabled = GL_TRUE; |
| ppca.glDisableVertexAttribArray( 3 ); |
| ppca.glDisableVertexArrayAttribEXT( 1, 3 ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::generic [ 3 ].enabled ); |
| } |
| |
| TEST ( RegalPpca, VertexArray_Named ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glEnableClientState( GL_COLOR_ARRAY ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| |
| ppca.glDisableClientState( GL_COLOR_ARRAY ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| |
| EXPECT_EQ( GLenum( GL_TEXTURE0 ), ppca.VertexArray::clientActiveTexture ); |
| |
| ppca.glClientActiveTexture( GL_TEXTURE2 ); |
| EXPECT_EQ( GLenum( GL_TEXTURE2 ), ppca.VertexArray::clientActiveTexture ); |
| |
| ppca.glEnableClientState( GL_TEXTURE_COORD_ARRAY ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::TEX_COORD + 2 ].enabled ); |
| |
| ppca.glDisableClientState( GL_TEXTURE_COORD_ARRAY ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::TEX_COORD + 2 ].enabled ); |
| |
| ppca.glEnableVertexArrayEXT( 0, GL_TEXTURE_COORD_ARRAY ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::TEX_COORD + 2 ].enabled ); |
| |
| ppca.glDisableVertexArrayEXT( 0, GL_TEXTURE_COORD_ARRAY ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::TEX_COORD + 2 ].enabled ); |
| |
| ppca.glEnableVertexArrayEXT( 1, GL_TEXTURE_COORD_ARRAY ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::TEX_COORD + 2 ].enabled ); |
| |
| ppca.glDisableVertexArrayEXT( 1, GL_TEXTURE_COORD_ARRAY ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::TEX_COORD + 2 ].enabled ); |
| |
| ppca.glEnableClientStateIndexedEXT( GL_TEXTURE_COORD_ARRAY, 5 ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::TEX_COORD + 5 ].enabled ); |
| |
| ppca.glDisableClientStateIndexedEXT( GL_TEXTURE_COORD_ARRAY, 5 ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::TEX_COORD + 5 ].enabled ); |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| ppca.VertexArray::named[ii].enabled = GLboolean(GL_FALSE); |
| ppca.VertexArray::named[ii].pointer = reinterpret_cast<const GLvoid*>(ii); |
| ppca.VertexArray::named[ii].buffer = GLuint(ii); |
| ppca.VertexArray::named[ii].size = GLint(ii); |
| ppca.VertexArray::named[ii].type = GLenum(ii); |
| ppca.VertexArray::named[ii].stride = GLuint(ii); |
| } |
| |
| ppca.VertexArray::arrayBufferBinding = 123; |
| |
| ppca.glVertexPointer( 4, GL_FLOAT, 1001, NULL ); |
| EXPECT_EQ( GLuint(123), ppca.VertexArray::named[ ClientState::VERTEX ].buffer ); |
| EXPECT_EQ( GLint(4), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLint(1001), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| |
| ppca.glNormalPointer( GL_FLOAT, 1002, NULL ); |
| EXPECT_EQ( GLuint(123), ppca.VertexArray::named[ ClientState::NORMAL ].buffer ); |
| EXPECT_EQ( GLint(3), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLint(1002), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| |
| ppca.glColorPointer( 4, GL_FLOAT, 1003, NULL ); |
| EXPECT_EQ( GLuint(123), ppca.VertexArray::named[ ClientState::COLOR ].buffer ); |
| EXPECT_EQ( GLint(4), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLint(1003), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| |
| ppca.glSecondaryColorPointer( 3, GL_FLOAT, 1004, NULL ); |
| EXPECT_EQ( GLuint(123), ppca.VertexArray::named[ ClientState::SECONDARY_COLOR ].buffer ); |
| EXPECT_EQ( GLint(3), ppca.VertexArray::named[ ClientState::SECONDARY_COLOR ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::SECONDARY_COLOR ].type ); |
| EXPECT_EQ( GLint(1004), ppca.VertexArray::named[ ClientState::SECONDARY_COLOR ].stride ); |
| |
| ppca.glIndexPointer( GL_INT, 1005, NULL ); |
| EXPECT_EQ( GLuint(123), ppca.VertexArray::named[ ClientState::INDEX ].buffer ); |
| EXPECT_EQ( GLint(1), ppca.VertexArray::named[ ClientState::INDEX ].size ); |
| EXPECT_EQ( GLenum( GL_INT ), ppca.VertexArray::named[ ClientState::INDEX ].type ); |
| EXPECT_EQ( GLint(1005), ppca.VertexArray::named[ ClientState::INDEX ].stride ); |
| |
| ppca.glEdgeFlagPointer( 1006, NULL ); |
| EXPECT_EQ( GLuint(123), ppca.VertexArray::named[ ClientState::EDGE_FLAG ].buffer ); |
| EXPECT_EQ( GLint(1), ppca.VertexArray::named[ ClientState::EDGE_FLAG ].size ); |
| EXPECT_EQ( GLenum( GL_BOOL ), ppca.VertexArray::named[ ClientState::EDGE_FLAG ].type ); |
| EXPECT_EQ( GLint(1006), ppca.VertexArray::named[ ClientState::EDGE_FLAG ].stride ); |
| |
| ppca.glFogCoordPointer( GL_FLOAT, 1007, NULL ); |
| EXPECT_EQ( GLuint(123), ppca.VertexArray::named[ ClientState::FOG_COORD ].buffer ); |
| EXPECT_EQ( GLint(1), ppca.VertexArray::named[ ClientState::FOG_COORD ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::FOG_COORD ].type ); |
| EXPECT_EQ( GLint(1007), ppca.VertexArray::named[ ClientState::FOG_COORD ].stride ); |
| |
| ppca.glTexCoordPointer( 2, GL_FLOAT, 1008, NULL ); |
| EXPECT_EQ( GLuint(123), ppca.VertexArray::named[ ClientState::TEX_COORD + 2].buffer ); |
| EXPECT_EQ( GLint(2), ppca.VertexArray::named[ ClientState::TEX_COORD + 2].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD + 2].type ); |
| EXPECT_EQ( GLint(1008), ppca.VertexArray::named[ ClientState::TEX_COORD + 2].stride ); |
| |
| ppca.glMultiTexCoordPointerEXT( GL_TEXTURE5, 2, GL_FLOAT, 2005, NULL ); |
| EXPECT_EQ( GLuint(123), ppca.VertexArray::named[ ClientState::TEX_COORD + 5].buffer ); |
| EXPECT_EQ( GLint(2), ppca.VertexArray::named[ ClientState::TEX_COORD + 5].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD + 5].type ); |
| EXPECT_EQ( GLint(2005), ppca.VertexArray::named[ ClientState::TEX_COORD + 5].stride ); |
| |
| ppca.glVertexArrayVertexOffsetEXT( 0, 3001, 3, GL_FLOAT, 3002, 0 ); |
| EXPECT_EQ( GLuint(3001), ppca.VertexArray::named[ ClientState::VERTEX ].buffer ); |
| EXPECT_EQ( GLint(3), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLint(3002), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| |
| ppca.glVertexArrayColorOffsetEXT ( 0, 3003, 4, GL_FLOAT, 3004, 0 ); |
| EXPECT_EQ( GLuint(3003), ppca.VertexArray::named[ ClientState::COLOR ].buffer ); |
| EXPECT_EQ( GLint(4), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLint(3004), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| |
| ppca.glVertexArrayEdgeFlagOffsetEXT ( 0, 3005, 3006, 0 ); |
| EXPECT_EQ( GLuint(3005), ppca.VertexArray::named[ ClientState::EDGE_FLAG ].buffer ); |
| EXPECT_EQ( GLint(1), ppca.VertexArray::named[ ClientState::EDGE_FLAG ].size ); |
| EXPECT_EQ( GLenum( GL_BOOL ), ppca.VertexArray::named[ ClientState::EDGE_FLAG ].type ); |
| EXPECT_EQ( GLint(3006), ppca.VertexArray::named[ ClientState::EDGE_FLAG ].stride ); |
| |
| ppca.glVertexArrayIndexOffsetEXT ( 0, 3007, GL_INT, 3008, 0 ); |
| EXPECT_EQ( GLuint(3007), ppca.VertexArray::named[ ClientState::INDEX ].buffer ); |
| EXPECT_EQ( GLint(1), ppca.VertexArray::named[ ClientState::INDEX ].size ); |
| EXPECT_EQ( GLenum( GL_INT ), ppca.VertexArray::named[ ClientState::INDEX ].type ); |
| EXPECT_EQ( GLint(3008), ppca.VertexArray::named[ ClientState::INDEX ].stride ); |
| |
| ppca.glVertexArrayNormalOffsetEXT ( 0, 3009, GL_FLOAT, 3010, 0 ); |
| EXPECT_EQ( GLuint(3009), ppca.VertexArray::named[ ClientState::NORMAL ].buffer ); |
| EXPECT_EQ( GLint(3), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLint(3010), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| |
| ppca.glVertexArrayTexCoordOffsetEXT( 0, 3011, 2, GL_FLOAT, 3012, 0 ); |
| EXPECT_EQ( GLuint(3011), ppca.VertexArray::named[ ClientState::TEX_COORD + 2 ].buffer ); |
| EXPECT_EQ( GLint(2), ppca.VertexArray::named[ ClientState::TEX_COORD + 2 ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD + 2 ].type ); |
| EXPECT_EQ( GLint(3012), ppca.VertexArray::named[ ClientState::TEX_COORD + 2 ].stride ); |
| |
| ppca.glVertexArrayMultiTexCoordOffsetEXT( 0, 3013, GL_TEXTURE5, 2, GL_FLOAT, 3014, 0 ); |
| EXPECT_EQ( GLuint(3013), ppca.VertexArray::named[ ClientState::TEX_COORD + 5 ].buffer ); |
| EXPECT_EQ( GLint(2), ppca.VertexArray::named[ ClientState::TEX_COORD + 5 ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD + 5 ].type ); |
| EXPECT_EQ( GLint(3014), ppca.VertexArray::named[ ClientState::TEX_COORD + 5 ].stride ); |
| |
| ppca.glVertexArrayFogCoordOffsetEXT ( 0, 3015, GL_FLOAT, 3016, 0 ); |
| EXPECT_EQ( GLuint(3015), ppca.VertexArray::named[ ClientState::FOG_COORD ].buffer ); |
| EXPECT_EQ( GLint(1), ppca.VertexArray::named[ ClientState::FOG_COORD ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::FOG_COORD ].type ); |
| EXPECT_EQ( GLint(3016), ppca.VertexArray::named[ ClientState::FOG_COORD ].stride ); |
| |
| ppca.glVertexArraySecondaryColorOffsetEXT ( 0, 3017, 3, GL_FLOAT, 3018, 0 ); |
| EXPECT_EQ( GLuint(3017), ppca.VertexArray::named[ ClientState::SECONDARY_COLOR ].buffer ); |
| EXPECT_EQ( GLint(3), ppca.VertexArray::named[ ClientState::SECONDARY_COLOR ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::SECONDARY_COLOR ].type ); |
| EXPECT_EQ( GLint(3018), ppca.VertexArray::named[ ClientState::SECONDARY_COLOR ].stride ); |
| } |
| |
| TEST ( RegalPpca, glDeleteBuffers_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| GLuint buffers[ 2 ] = { 0, 123 }; |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.VertexArray::bindings[ii].buffer = GLuint(123); |
| } |
| ppca.VertexArray::elementArrayBufferBinding = GLuint(123); |
| ppca.VertexArray::arrayBufferBinding = GLuint(123); |
| ppca.PixelStore::pixelPackBufferBinding = GLuint(123); |
| ppca.PixelStore::pixelUnpackBufferBinding = GLuint(123); |
| |
| ppca.glDeleteBuffers( 2, buffers ); |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.VertexArray::bindings[ii].buffer = GLuint(456); |
| } |
| ppca.VertexArray::elementArrayBufferBinding = GLuint(456); |
| ppca.VertexArray::arrayBufferBinding = GLuint(456); |
| ppca.PixelStore::pixelPackBufferBinding = GLuint(456); |
| ppca.PixelStore::pixelUnpackBufferBinding = GLuint(456); |
| |
| ppca.glDeleteBuffers( 2, buffers ); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| EXPECT_EQ( GLuint(456), ppca.VertexArray::bindings[ii].buffer ); |
| } |
| EXPECT_EQ( GLuint(456), ppca.VertexArray::elementArrayBufferBinding ); |
| EXPECT_EQ( GLuint(456), ppca.VertexArray::arrayBufferBinding ); |
| EXPECT_EQ( GLuint(456), ppca.PixelStore::pixelPackBufferBinding ); |
| EXPECT_EQ( GLuint(456), ppca.PixelStore::pixelUnpackBufferBinding ); |
| } |
| |
| TEST ( RegalPpca, glDeleteVertexArrays_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| GLuint buffers[ 2 ] = { 0, 123 }; |
| |
| ppca.VertexArray::vertexArrayBinding = 123; |
| |
| ppca.glDeleteVertexArrays( 2, buffers ); |
| |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::vertexArrayBinding ); |
| |
| ppca.VertexArray::vertexArrayBinding = 456; |
| |
| ppca.glDeleteVertexArrays( 2, buffers ); |
| |
| EXPECT_EQ( GLuint(456), ppca.VertexArray::vertexArrayBinding ); |
| } |
| |
| TEST ( RegalPpca, glPrimitiveRestart_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.primitiveRestartFixedIndex ); |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::primitiveRestartIndex ); |
| |
| // test glEnable & glDisable |
| |
| ppca.glEnable( GL_PRIMITIVE_RESTART ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.glDisable( GL_PRIMITIVE_RESTART ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.glEnable( GL_PRIMITIVE_RESTART_FIXED_INDEX ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.glDisable( GL_PRIMITIVE_RESTART_FIXED_INDEX ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| |
| ppca.glEnable( GL_TEXTURE_GEN_S ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.glDisable( GL_TEXTURE_GEN_S ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.VertexArray::primitiveRestart = GL_TRUE; |
| ppca.VertexArray::primitiveRestartFixedIndex = GL_TRUE; |
| ppca.glEnable( GL_TEXTURE_GEN_S ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.glDisable( GL_TEXTURE_GEN_S ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| |
| // test glEnablei & glDisablei |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glEnablei( GL_PRIMITIVE_RESTART, 0 ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.glDisablei( GL_PRIMITIVE_RESTART, 0 ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.glEnablei( GL_PRIMITIVE_RESTART_FIXED_INDEX, 0 ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.glDisablei( GL_PRIMITIVE_RESTART_FIXED_INDEX, 0 ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| |
| ppca.glEnablei( GL_TEXTURE_GEN_S, 0 ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.glDisablei( GL_TEXTURE_GEN_S, 0 ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.VertexArray::primitiveRestart = GL_TRUE; |
| ppca.VertexArray::primitiveRestartFixedIndex = GL_TRUE; |
| ppca.glEnablei( GL_TEXTURE_GEN_S, 0 ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.glDisablei( GL_TEXTURE_GEN_S, 0 ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| |
| // test glEnableIndexedEXT & glDisableIndexedEXT |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glEnableIndexedEXT( GL_PRIMITIVE_RESTART, 0 ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.glDisableIndexedEXT( GL_PRIMITIVE_RESTART, 0 ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.glEnableIndexedEXT( GL_PRIMITIVE_RESTART_FIXED_INDEX, 0 ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.glDisableIndexedEXT( GL_PRIMITIVE_RESTART_FIXED_INDEX, 0 ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| |
| ppca.glEnableIndexedEXT( GL_TEXTURE_GEN_S, 0 ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.glDisableIndexedEXT( GL_TEXTURE_GEN_S, 0 ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.VertexArray::primitiveRestart = GL_TRUE; |
| ppca.VertexArray::primitiveRestartFixedIndex = GL_TRUE; |
| ppca.glEnableIndexedEXT( GL_TEXTURE_GEN_S, 0 ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| ppca.glDisableIndexedEXT( GL_TEXTURE_GEN_S, 0 ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestart ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::primitiveRestartFixedIndex ); |
| |
| // test glPrimitiveRestartIndex |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=0; ii<13; ii++) |
| { |
| ppca.glPrimitiveRestartIndex( ii ); |
| EXPECT_EQ( GLuint(ii), ppca.VertexArray::primitiveRestartIndex ); |
| } |
| |
| ppca.glPrimitiveRestartIndex( GLuint(~0) ); |
| EXPECT_EQ( GLuint(~0), ppca.VertexArray::primitiveRestartIndex ); |
| } |
| |
| TEST ( RegalPpca, glInterleavedArrays_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // Do a comprehensive test on all settings for GL_T4F_C4F_N3F_V4F |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| ppca.VertexArray::named[ ii ].enabled = GLboolean( ( ii & 1 ) == 0 ); |
| ppca.VertexArray::named[ ii ].size = GLint( 987 ); |
| ppca.VertexArray::named[ ii ].type = GLenum( 987 ); |
| ppca.VertexArray::named[ ii ].stride = GLint( 987 ); |
| ppca.VertexArray::named[ ii ].pointer = reinterpret_cast<const GLvoid*>( 987 ); |
| } |
| |
| ppca.glClientActiveTexture( GL_TEXTURE5 ); |
| ppca.glInterleavedArrays( GL_T4F_C4F_N3F_V4F, 0, NULL ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::VERTEX ].enabled ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLint( 60 ), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 44 ), ppca.VertexArray::named[ ClientState::VERTEX ].pointer ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::NORMAL ].enabled ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLint( 60 ), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 32 ), ppca.VertexArray::named[ ClientState::NORMAL ].pointer ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLint( 60 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 16 ), ppca.VertexArray::named[ ClientState::COLOR ].pointer ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::TEX_COORD + 5 ].enabled ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::TEX_COORD + 5 ].size ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD + 5 ].type ); |
| EXPECT_EQ( GLint( 60 ), ppca.VertexArray::named[ ClientState::TEX_COORD + 5 ].stride ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD + 5 ].pointer ); |
| |
| // The other non-texture coordinate arrays should be disabled |
| |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::EDGE_FLAG ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::FOG_COORD ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::INDEX ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::SECONDARY_COLOR ].enabled ); |
| |
| // The other non-texture coordinate arrays should not otherwise be touched. |
| |
| EXPECT_EQ( GLint( 987 ), ppca.VertexArray::named[ ClientState::EDGE_FLAG ].size ); |
| EXPECT_EQ( GLenum( 987 ), ppca.VertexArray::named[ ClientState::EDGE_FLAG ].type ); |
| EXPECT_EQ( GLint( 987 ), ppca.VertexArray::named[ ClientState::EDGE_FLAG ].stride ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 987 ), ppca.VertexArray::named[ ClientState::EDGE_FLAG ].pointer ); |
| |
| EXPECT_EQ( GLint( 987 ), ppca.VertexArray::named[ ClientState::FOG_COORD ].size ); |
| EXPECT_EQ( GLenum( 987 ), ppca.VertexArray::named[ ClientState::FOG_COORD ].type ); |
| EXPECT_EQ( GLint( 987 ), ppca.VertexArray::named[ ClientState::FOG_COORD ].stride ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 987 ), ppca.VertexArray::named[ ClientState::FOG_COORD ].pointer ); |
| |
| EXPECT_EQ( GLint( 987 ), ppca.VertexArray::named[ ClientState::INDEX ].size ); |
| EXPECT_EQ( GLenum( 987 ), ppca.VertexArray::named[ ClientState::INDEX ].type ); |
| EXPECT_EQ( GLint( 987 ), ppca.VertexArray::named[ ClientState::INDEX ].stride ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 987 ), ppca.VertexArray::named[ ClientState::INDEX ].pointer ); |
| |
| EXPECT_EQ( GLint( 987 ), ppca.VertexArray::named[ ClientState::SECONDARY_COLOR ].size ); |
| EXPECT_EQ( GLenum( 987 ), ppca.VertexArray::named[ ClientState::SECONDARY_COLOR ].type ); |
| EXPECT_EQ( GLint( 987 ), ppca.VertexArray::named[ ClientState::SECONDARY_COLOR ].stride ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 987 ), ppca.VertexArray::named[ ClientState::SECONDARY_COLOR ].pointer ); |
| |
| // Verify other texture coordinate settings unaffected. |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_TEXTURE_COORDS; ii++) |
| { |
| if ( ii == 5 ) |
| continue; |
| |
| GLboolean b = ( ( ( ClientState::TEX_COORD + ii ) & 1 ) == 0 ) ? GL_TRUE : GL_FALSE; |
| |
| EXPECT_EQ( GLboolean( b ), ppca.VertexArray::named[ ClientState::TEX_COORD + ii ].enabled ); |
| EXPECT_EQ( GLint( 987 ), ppca.VertexArray::named[ ClientState::TEX_COORD + ii ].size ); |
| EXPECT_EQ( GLenum( 987 ), ppca.VertexArray::named[ ClientState::TEX_COORD + ii ].type ); |
| EXPECT_EQ( GLint( 987 ), ppca.VertexArray::named[ ClientState::TEX_COORD + ii ].stride ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 987 ), ppca.VertexArray::named[ ClientState::TEX_COORD + ii ].pointer ); |
| } |
| |
| // Ensure if stride is nonzero, it is used as is, and ensure the pointer passed in is used as a base address. |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glClientActiveTexture( GL_TEXTURE5 ); |
| ppca.glInterleavedArrays( GL_T4F_C4F_N3F_V4F, 321, reinterpret_cast<GLvoid *>( 5000 ) ); |
| |
| EXPECT_EQ( GLint( 321 ), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 5044 ), ppca.VertexArray::named[ ClientState::VERTEX ].pointer ); |
| EXPECT_EQ( GLint( 321 ), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 5032 ), ppca.VertexArray::named[ ClientState::NORMAL ].pointer ); |
| EXPECT_EQ( GLint( 321 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 5016 ), ppca.VertexArray::named[ ClientState::COLOR ].pointer ); |
| EXPECT_EQ( GLint( 321 ), ppca.VertexArray::named[ ClientState::TEX_COORD + 5 ].stride ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 5000 ), ppca.VertexArray::named[ ClientState::TEX_COORD + 5 ].pointer ); |
| |
| // Do a quick run through the remaining formats, and do some quick verifications. |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glInterleavedArrays( GL_V2F, 0, NULL ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::VERTEX ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::NORMAL ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::TEX_COORD ].enabled ); |
| |
| EXPECT_EQ( GLint( 2 ), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].size ); |
| |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD ].type ); |
| |
| EXPECT_EQ( GLint( 8 ), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].stride ); |
| |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::VERTEX ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].pointer ); |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glInterleavedArrays( GL_V3F, 0, NULL ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::VERTEX ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::NORMAL ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::TEX_COORD ].enabled ); |
| |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].size ); |
| |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD ].type ); |
| |
| EXPECT_EQ( GLint( 12 ), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].stride ); |
| |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::VERTEX ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].pointer ); |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glInterleavedArrays( GL_C4UB_V2F, 0, NULL ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::VERTEX ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::NORMAL ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::TEX_COORD ].enabled ); |
| |
| EXPECT_EQ( GLint( 2 ), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].size ); |
| |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLenum( GL_UNSIGNED_BYTE ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD ].type ); |
| |
| EXPECT_EQ( GLint( 12 ), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| EXPECT_EQ( GLint( 12 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].stride ); |
| |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 4 ), ppca.VertexArray::named[ ClientState::VERTEX ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].pointer ); |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glInterleavedArrays( GL_C4UB_V3F, 0, NULL ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::VERTEX ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::NORMAL ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::TEX_COORD ].enabled ); |
| |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].size ); |
| |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLenum( GL_UNSIGNED_BYTE ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD ].type ); |
| |
| EXPECT_EQ( GLint( 16 ), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| EXPECT_EQ( GLint( 16 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].stride ); |
| |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 4 ), ppca.VertexArray::named[ ClientState::VERTEX ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].pointer ); |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glInterleavedArrays( GL_C3F_V3F, 0, NULL ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::VERTEX ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::NORMAL ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::TEX_COORD ].enabled ); |
| |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].size ); |
| |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD ].type ); |
| |
| EXPECT_EQ( GLint( 24 ), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| EXPECT_EQ( GLint( 24 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].stride ); |
| |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 12 ), ppca.VertexArray::named[ ClientState::VERTEX ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].pointer ); |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glInterleavedArrays( GL_N3F_V3F, 0, NULL ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::VERTEX ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::NORMAL ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::TEX_COORD ].enabled ); |
| |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].size ); |
| |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD ].type ); |
| |
| EXPECT_EQ( GLint( 24 ), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| EXPECT_EQ( GLint( 24 ), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].stride ); |
| |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 12 ), ppca.VertexArray::named[ ClientState::VERTEX ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].pointer ); |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glInterleavedArrays( GL_C4F_N3F_V3F, 0, NULL ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::VERTEX ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::NORMAL ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::TEX_COORD ].enabled ); |
| |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].size ); |
| |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD ].type ); |
| |
| EXPECT_EQ( GLint( 40 ), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| EXPECT_EQ( GLint( 40 ), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| EXPECT_EQ( GLint( 40 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].stride ); |
| |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 28 ), ppca.VertexArray::named[ ClientState::VERTEX ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 16 ), ppca.VertexArray::named[ ClientState::NORMAL ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].pointer ); |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glInterleavedArrays( GL_T2F_V3F, 0, NULL ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::VERTEX ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::NORMAL ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::TEX_COORD ].enabled ); |
| |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLint( 2 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].size ); |
| |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD ].type ); |
| |
| EXPECT_EQ( GLint( 20 ), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( GLint( 20 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].stride ); |
| |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 8 ), ppca.VertexArray::named[ ClientState::VERTEX ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].pointer ); |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glInterleavedArrays( GL_T4F_V4F, 0, NULL ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::VERTEX ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::NORMAL ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::TEX_COORD ].enabled ); |
| |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].size ); |
| |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD ].type ); |
| |
| EXPECT_EQ( GLint( 32 ), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( GLint( 32 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].stride ); |
| |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 16 ), ppca.VertexArray::named[ ClientState::VERTEX ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].pointer ); |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glInterleavedArrays( GL_T2F_C4UB_V3F, 0, NULL ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::VERTEX ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::NORMAL ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::TEX_COORD ].enabled ); |
| |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLint( 2 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].size ); |
| |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLenum( GL_UNSIGNED_BYTE ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD ].type ); |
| |
| EXPECT_EQ( GLint( 24 ), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| EXPECT_EQ( GLint( 24 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( GLint( 24 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].stride ); |
| |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 12 ), ppca.VertexArray::named[ ClientState::VERTEX ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 8 ), ppca.VertexArray::named[ ClientState::COLOR ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].pointer ); |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glInterleavedArrays( GL_T2F_C3F_V3F, 0, NULL ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::VERTEX ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::NORMAL ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::TEX_COORD ].enabled ); |
| |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLint( 2 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].size ); |
| |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD ].type ); |
| |
| EXPECT_EQ( GLint( 32 ), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| EXPECT_EQ( GLint( 32 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( GLint( 32 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].stride ); |
| |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 20 ), ppca.VertexArray::named[ ClientState::VERTEX ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::NORMAL ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 8 ), ppca.VertexArray::named[ ClientState::COLOR ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].pointer ); |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glInterleavedArrays( GL_T2F_N3F_V3F, 0, NULL ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::VERTEX ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::NORMAL ].enabled ); |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::TEX_COORD ].enabled ); |
| |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLint( 2 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].size ); |
| |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD ].type ); |
| |
| EXPECT_EQ( GLint( 32 ), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| EXPECT_EQ( GLint( 32 ), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| EXPECT_EQ( GLint( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( GLint( 32 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].stride ); |
| |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 20 ), ppca.VertexArray::named[ ClientState::VERTEX ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 8 ), ppca.VertexArray::named[ ClientState::NORMAL ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::COLOR ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].pointer ); |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glInterleavedArrays( GL_T2F_C4F_N3F_V3F, 0, NULL ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::VERTEX ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::NORMAL ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::COLOR ].enabled ); |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.VertexArray::named[ ClientState::TEX_COORD ].enabled ); |
| |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::VERTEX ].size ); |
| EXPECT_EQ( GLint( 3 ), ppca.VertexArray::named[ ClientState::NORMAL ].size ); |
| EXPECT_EQ( GLint( 4 ), ppca.VertexArray::named[ ClientState::COLOR ].size ); |
| EXPECT_EQ( GLint( 2 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].size ); |
| |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::VERTEX ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::NORMAL ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::COLOR ].type ); |
| EXPECT_EQ( GLenum( GL_FLOAT ), ppca.VertexArray::named[ ClientState::TEX_COORD ].type ); |
| |
| EXPECT_EQ( GLint( 48 ), ppca.VertexArray::named[ ClientState::VERTEX ].stride ); |
| EXPECT_EQ( GLint( 48 ), ppca.VertexArray::named[ ClientState::NORMAL ].stride ); |
| EXPECT_EQ( GLint( 48 ), ppca.VertexArray::named[ ClientState::COLOR ].stride ); |
| EXPECT_EQ( GLint( 48 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].stride ); |
| |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 36 ), ppca.VertexArray::named[ ClientState::VERTEX ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 24 ), ppca.VertexArray::named[ ClientState::NORMAL ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 8 ), ppca.VertexArray::named[ ClientState::COLOR ].pointer ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 0 ), ppca.VertexArray::named[ ClientState::TEX_COORD ].pointer ); |
| |
| // Pass in an unsupported "format", which should do nothing. |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| ppca.VertexArray::named[ ii ].enabled = GLboolean( ( ii & 1 ) == 0 ); |
| ppca.VertexArray::named[ ii ].size = GLint( 987 ); |
| ppca.VertexArray::named[ ii ].type = GLenum( 987 ); |
| ppca.VertexArray::named[ ii ].stride = GLint( 987 ); |
| ppca.VertexArray::named[ ii ].pointer = reinterpret_cast<const GLvoid*>( 987 ); |
| } |
| |
| ppca.glInterleavedArrays( GL_RGBA, 0, NULL ); |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| GLboolean b = ( ( ( ii ) & 1 ) == 0 ) ? GL_TRUE : GL_FALSE; |
| |
| EXPECT_EQ( GLboolean( b ), ppca.VertexArray::named[ ii ].enabled ); |
| EXPECT_EQ( GLint( 987 ), ppca.VertexArray::named[ ii ].size ); |
| EXPECT_EQ( GLenum( 987 ), ppca.VertexArray::named[ ii ].type ); |
| EXPECT_EQ( GLint( 987 ), ppca.VertexArray::named[ ii ].stride ); |
| EXPECT_EQ( reinterpret_cast<const GLvoid*>( 987 ), ppca.VertexArray::named[ ii ].pointer ); |
| } |
| } |
| |
| TEST ( RegalPpca, glGet_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| GLint resulti[ 1 ] = { 123 }; |
| GLint64 resulti64[ 1 ] = { 123 }; |
| GLfloat resultf[ 1 ] = { 123.f }; |
| GLdouble resultd[ 1 ] = { 123. }; |
| GLboolean resultb[ 1 ] = { GL_FALSE }; |
| |
| // First ensure getting an unimplemented value works (does nothing). |
| |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.glGetv( ctx, GL_FLOAT, resulti ) ); |
| EXPECT_EQ( 123, resulti[ 0 ] ); |
| |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.glGetv( ctx, GL_FLOAT, resulti64 ) ); |
| EXPECT_EQ( 123, resulti64[ 0 ] ); |
| |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.glGetv( ctx, GL_FLOAT, resultf ) ); |
| EXPECT_EQ( 123, resultf[ 0 ] ); |
| |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.glGetv( ctx, GL_FLOAT, resultd ) ); |
| EXPECT_EQ( 123, resultd[ 0 ] ); |
| |
| EXPECT_EQ( GLboolean( GL_FALSE ), ppca.glGetv( ctx, GL_FLOAT, resultb ) ); |
| EXPECT_EQ( GLboolean(GL_FALSE), resultb[ 0 ] ); |
| |
| // Next verify that getting an implemented value gets the value. |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv( ctx, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, resulti ) ); |
| EXPECT_EQ( REGAL_EMU_MAX_CLIENT_ATTRIB_STACK_DEPTH, resulti[ 0 ] ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv( ctx, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, resulti64 ) ); |
| EXPECT_EQ( REGAL_EMU_MAX_CLIENT_ATTRIB_STACK_DEPTH, resulti64[ 0 ] ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv( ctx, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, resultf ) ); |
| EXPECT_EQ( REGAL_EMU_MAX_CLIENT_ATTRIB_STACK_DEPTH, resultf[ 0 ] ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv( ctx, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, resultd ) ); |
| EXPECT_EQ( REGAL_EMU_MAX_CLIENT_ATTRIB_STACK_DEPTH, resultd[ 0 ] ); |
| |
| EXPECT_EQ( GLboolean( GL_TRUE ), ppca.glGetv( ctx, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, resultb ) ); |
| EXPECT_EQ( GLboolean(GL_TRUE), resultb[ 0 ] ); |
| } |
| |
| TEST ( RegalPpca, glPixelStore_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // first test glPixelStorei |
| |
| ppca.glPixelStore( GL_UNPACK_SWAP_BYTES, GLint(GL_TRUE) ); |
| ppca.glPixelStore( GL_UNPACK_LSB_FIRST, GLint(GL_TRUE) ); |
| ppca.glPixelStore( GL_UNPACK_IMAGE_HEIGHT, GLint(11) ); |
| ppca.glPixelStore( GL_UNPACK_SKIP_IMAGES, GLint(12) ); |
| ppca.glPixelStore( GL_UNPACK_ROW_LENGTH, GLint(13) ); |
| ppca.glPixelStore( GL_UNPACK_SKIP_ROWS, GLint(14) ); |
| ppca.glPixelStore( GL_UNPACK_SKIP_PIXELS, GLint(15) ); |
| ppca.glPixelStore( GL_UNPACK_ALIGNMENT, GLint(16) ); |
| ppca.glPixelStore( GL_PACK_SWAP_BYTES, GLint(GL_TRUE) ); |
| ppca.glPixelStore( GL_PACK_LSB_FIRST, GLint(GL_TRUE) ); |
| ppca.glPixelStore( GL_PACK_IMAGE_HEIGHT, GLint(27) ); |
| ppca.glPixelStore( GL_PACK_SKIP_IMAGES, GLint(28) ); |
| ppca.glPixelStore( GL_PACK_ROW_LENGTH, GLint(29) ); |
| ppca.glPixelStore( GL_PACK_SKIP_ROWS, GLint(30) ); |
| ppca.glPixelStore( GL_PACK_SKIP_PIXELS, GLint(31) ); |
| ppca.glPixelStore( GL_PACK_ALIGNMENT, GLint(32) ); |
| |
| ppca.glBindBuffer( GL_PIXEL_UNPACK_BUFFER, GLuint(123) ); |
| ppca.glBindBuffer( GL_PIXEL_PACK_BUFFER, GLuint(456) ); |
| |
| EXPECT_EQ( GLint(GL_TRUE), ppca.PixelStore::unpackSwapBytes ); |
| EXPECT_EQ( GLint(GL_TRUE), ppca.PixelStore::unpackLsbFirst ); |
| EXPECT_EQ( GLint(11), ppca.PixelStore::unpackImageHeight ); |
| EXPECT_EQ( GLint(12), ppca.PixelStore::unpackSkipImages ); |
| EXPECT_EQ( GLint(13), ppca.PixelStore::unpackRowLength ); |
| EXPECT_EQ( GLint(14), ppca.PixelStore::unpackSkipRows ); |
| EXPECT_EQ( GLint(15), ppca.PixelStore::unpackSkipPixels ); |
| EXPECT_EQ( GLint(16), ppca.PixelStore::unpackAlignment ); |
| EXPECT_EQ( GLint(GL_TRUE), ppca.PixelStore::packSwapBytes ); |
| EXPECT_EQ( GLint(GL_TRUE), ppca.PixelStore::packLsbFirst ); |
| EXPECT_EQ( GLint(27), ppca.PixelStore::packImageHeight ); |
| EXPECT_EQ( GLint(28), ppca.PixelStore::packSkipImages ); |
| EXPECT_EQ( GLint(29), ppca.PixelStore::packRowLength ); |
| EXPECT_EQ( GLint(30), ppca.PixelStore::packSkipRows ); |
| EXPECT_EQ( GLint(31), ppca.PixelStore::packSkipPixels ); |
| EXPECT_EQ( GLint(32), ppca.PixelStore::packAlignment ); |
| EXPECT_EQ( GLuint(123), ppca.PixelStore::pixelUnpackBufferBinding ); |
| EXPECT_EQ( GLuint(456), ppca.PixelStore::pixelPackBufferBinding ); |
| |
| // reset just the pixel store state then verify that |
| // the entire ppca is now back to default state |
| |
| ppca.PixelStore::Reset(); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // now test glPixelStoref |
| |
| ppca.glPixelStore( GL_UNPACK_SWAP_BYTES, GLfloat(1.11) ); |
| ppca.glPixelStore( GL_UNPACK_LSB_FIRST, GLfloat(0) ); |
| ppca.glPixelStore( GL_UNPACK_IMAGE_HEIGHT, GLfloat(11.0) ); |
| ppca.glPixelStore( GL_UNPACK_SKIP_IMAGES, GLfloat(12.1) ); |
| ppca.glPixelStore( GL_UNPACK_ROW_LENGTH, GLfloat(13.2) ); |
| ppca.glPixelStore( GL_UNPACK_SKIP_ROWS, GLfloat(14.3) ); |
| ppca.glPixelStore( GL_UNPACK_SKIP_PIXELS, GLfloat(15.4) ); |
| ppca.glPixelStore( GL_UNPACK_ALIGNMENT, GLfloat(16.5) ); |
| ppca.glPixelStore( GL_PACK_SWAP_BYTES, GLfloat(GL_TRUE) ); |
| ppca.glPixelStore( GL_PACK_LSB_FIRST, GLfloat(GL_TRUE) ); |
| ppca.glPixelStore( GL_PACK_IMAGE_HEIGHT, GLfloat(27.01) ); |
| ppca.glPixelStore( GL_PACK_SKIP_IMAGES, GLfloat(28.02) ); |
| ppca.glPixelStore( GL_PACK_ROW_LENGTH, GLfloat(29.03) ); |
| ppca.glPixelStore( GL_PACK_SKIP_ROWS, GLfloat(30.04) ); |
| ppca.glPixelStore( GL_PACK_SKIP_PIXELS, GLfloat(31.05) ); |
| ppca.glPixelStore( GL_PACK_ALIGNMENT, GLfloat(32.06) ); |
| |
| ppca.glBindBuffer( GL_PIXEL_UNPACK_BUFFER, GLuint(123) ); |
| ppca.glBindBuffer( GL_PIXEL_PACK_BUFFER, GLuint(456) ); |
| |
| EXPECT_EQ( GLfloat(GL_TRUE), ppca.PixelStore::unpackSwapBytes ); |
| EXPECT_EQ( GLfloat(GL_FALSE), ppca.PixelStore::unpackLsbFirst ); |
| EXPECT_EQ( GLfloat(11), ppca.PixelStore::unpackImageHeight ); |
| EXPECT_EQ( GLfloat(12), ppca.PixelStore::unpackSkipImages ); |
| EXPECT_EQ( GLfloat(13), ppca.PixelStore::unpackRowLength ); |
| EXPECT_EQ( GLfloat(14), ppca.PixelStore::unpackSkipRows ); |
| EXPECT_EQ( GLfloat(15), ppca.PixelStore::unpackSkipPixels ); |
| EXPECT_EQ( GLfloat(16), ppca.PixelStore::unpackAlignment ); |
| EXPECT_EQ( GLfloat(GL_TRUE), ppca.PixelStore::packSwapBytes ); |
| EXPECT_EQ( GLfloat(GL_TRUE), ppca.PixelStore::packLsbFirst ); |
| EXPECT_EQ( GLfloat(27), ppca.PixelStore::packImageHeight ); |
| EXPECT_EQ( GLfloat(28), ppca.PixelStore::packSkipImages ); |
| EXPECT_EQ( GLfloat(29), ppca.PixelStore::packRowLength ); |
| EXPECT_EQ( GLfloat(30), ppca.PixelStore::packSkipRows ); |
| EXPECT_EQ( GLfloat(31), ppca.PixelStore::packSkipPixels ); |
| EXPECT_EQ( GLfloat(32), ppca.PixelStore::packAlignment ); |
| EXPECT_EQ( GLuint(123), ppca.PixelStore::pixelUnpackBufferBinding ); |
| EXPECT_EQ( GLuint(456), ppca.PixelStore::pixelPackBufferBinding ); |
| } |
| |
| TEST ( RegalPpca, glBindBuffer_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::arrayBufferBinding = 0; |
| ppca.VertexArray::elementArrayBufferBinding = 0; |
| ppca.PixelStore::pixelUnpackBufferBinding = 0; |
| ppca.PixelStore::pixelPackBufferBinding = 0; |
| |
| ppca.glBindBuffer( GL_ARRAY_BUFFER, GLuint(12) ); |
| EXPECT_EQ( GLuint(12), ppca.VertexArray::arrayBufferBinding ); |
| EXPECT_EQ( GLuint( 0), ppca.VertexArray::elementArrayBufferBinding ); |
| EXPECT_EQ( GLuint( 0), ppca.PixelStore::pixelUnpackBufferBinding ); |
| EXPECT_EQ( GLuint( 0), ppca.PixelStore::pixelPackBufferBinding ); |
| |
| ppca.glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, GLuint(34) ); |
| EXPECT_EQ( GLuint(12), ppca.VertexArray::arrayBufferBinding ); |
| EXPECT_EQ( GLuint(34), ppca.VertexArray::elementArrayBufferBinding ); |
| EXPECT_EQ( GLuint( 0), ppca.PixelStore::pixelUnpackBufferBinding ); |
| EXPECT_EQ( GLuint( 0), ppca.PixelStore::pixelPackBufferBinding ); |
| |
| ppca.glBindBuffer( GL_PIXEL_UNPACK_BUFFER, GLuint(21) ); |
| EXPECT_EQ( GLuint(12), ppca.VertexArray::arrayBufferBinding ); |
| EXPECT_EQ( GLuint(34), ppca.VertexArray::elementArrayBufferBinding ); |
| EXPECT_EQ( GLuint(21), ppca.PixelStore::pixelUnpackBufferBinding ); |
| EXPECT_EQ( GLuint( 0), ppca.PixelStore::pixelPackBufferBinding ); |
| |
| ppca.glBindBuffer( GL_PIXEL_PACK_BUFFER, GLuint(43) ); |
| EXPECT_EQ( GLuint(12), ppca.VertexArray::arrayBufferBinding ); |
| EXPECT_EQ( GLuint(34), ppca.VertexArray::elementArrayBufferBinding ); |
| EXPECT_EQ( GLuint(21), ppca.PixelStore::pixelUnpackBufferBinding ); |
| EXPECT_EQ( GLuint(43), ppca.PixelStore::pixelPackBufferBinding ); |
| |
| GLuint validBuffers[] = { GL_ATOMIC_COUNTER_BUFFER, |
| GL_COPY_READ_BUFFER, |
| GL_COPY_WRITE_BUFFER, |
| GL_DRAW_INDIRECT_BUFFER, |
| GL_DISPATCH_INDIRECT_BUFFER, |
| GL_SHADER_STORAGE_BUFFER, |
| GL_TEXTURE_BUFFER, |
| GL_TRANSFORM_FEEDBACK_BUFFER, |
| GL_UNIFORM_BUFFER }; |
| GLuint nValidBuffers = sizeof(validBuffers)/sizeof(GLuint); |
| |
| for (GLuint n=0; n<nValidBuffers; n++) |
| { |
| ppca.glBindBuffer( validBuffers[n], GLuint(56) ); |
| EXPECT_EQ( GLuint(12), ppca.VertexArray::arrayBufferBinding ); |
| EXPECT_EQ( GLuint(34), ppca.VertexArray::elementArrayBufferBinding ); |
| EXPECT_EQ( GLuint(21), ppca.PixelStore::pixelUnpackBufferBinding ); |
| EXPECT_EQ( GLuint(43), ppca.PixelStore::pixelPackBufferBinding ); |
| } |
| |
| GLuint invalidBuffers[] = { GL_ARRAY_BUFFER_BINDING, |
| GL_ATOMIC_COUNTER_BUFFER_BINDING, |
| GL_DRAW_INDIRECT_BUFFER_BINDING, |
| GL_DISPATCH_INDIRECT_BUFFER_BINDING, |
| GL_ELEMENT_ARRAY_BUFFER_BINDING, |
| GL_PIXEL_PACK_BUFFER_BINDING, |
| GL_PIXEL_UNPACK_BUFFER_BINDING, |
| GL_SHADER_STORAGE_BUFFER_BINDING, |
| GL_TEXTURE_BUFFER_DATA_STORE_BINDING, |
| GL_TEXTURE_BUFFER_FORMAT, |
| GL_TEXTURE_BUFFER_OFFSET, |
| GL_TEXTURE_BUFFER_SIZE, |
| GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT, |
| GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, |
| GL_UNIFORM_BUFFER_BINDING }; |
| GLuint nInvalidBuffers = sizeof(invalidBuffers)/sizeof(GLuint); |
| |
| for (GLuint n=0; n<nInvalidBuffers; n++) |
| { |
| ppca.glBindBuffer( invalidBuffers[n], GLuint(78) ); |
| EXPECT_EQ( GLuint(12), ppca.VertexArray::arrayBufferBinding ); |
| EXPECT_EQ( GLuint(34), ppca.VertexArray::elementArrayBufferBinding ); |
| EXPECT_EQ( GLuint(21), ppca.PixelStore::pixelUnpackBufferBinding ); |
| EXPECT_EQ( GLuint(43), ppca.PixelStore::pixelPackBufferBinding ); |
| } |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glBindBuffer( GL_ARRAY_BUFFER, GLuint(123) ); |
| ppca.glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, GLuint(789) ); |
| ppca.glBindBuffer( GL_PIXEL_PACK_BUFFER, GLuint(321) ); |
| ppca.glBindBuffer( GL_PIXEL_UNPACK_BUFFER, GLuint(654) ); |
| |
| EXPECT_EQ( GLuint(123), ppca.VertexArray::arrayBufferBinding ); |
| EXPECT_EQ( GLuint( 0), ppca.VertexArray::elementArrayBufferBinding ); |
| EXPECT_EQ( GLuint(321), ppca.PixelStore::pixelPackBufferBinding ); |
| EXPECT_EQ( GLuint(654), ppca.PixelStore::pixelUnpackBufferBinding ); |
| } |
| |
| TEST ( RegalPpca, glClientActiveTexture_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=0; ii<(REGAL_EMU_MAX_TEXTURE_COORDS * 2); ii++) |
| { |
| GLenum test = GLenum(GL_TEXTURE0 + ii); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.VertexArray::clientActiveTexture = GLenum(0); |
| ppca.glClientActiveTexture( test ); |
| |
| if (ii < REGAL_EMU_MAX_TEXTURE_COORDS) |
| EXPECT_EQ( test, ppca.VertexArray::clientActiveTexture ); |
| else |
| EXPECT_EQ( GLenum(0), ppca.VertexArray::clientActiveTexture ); |
| |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| for (GLuint ii=0; ii<(REGAL_EMU_MAX_TEXTURE_COORDS * 2); ii++) |
| { |
| GLenum test = GLenum(GL_TEXTURE0 + ii); |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.VertexArray::clientActiveTexture = GLenum(0); |
| ppca.glClientActiveTexture( test ); |
| |
| if (ii < REGAL_EMU_MAX_TEXTURE_COORDS) |
| EXPECT_EQ( test, ppca.VertexArray::clientActiveTexture ); |
| else |
| EXPECT_EQ( GLenum(0), ppca.VertexArray::clientActiveTexture ); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| |
| TEST ( RegalPpca, glEnableDisableClientState_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test glEnableClientState & glDisableClientState with no vertex array bound |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| if (ii < 7) |
| { |
| ppca.glEnableClientState( Regal::ClientState::vaEnum[ii][0] ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableClientState( Regal::ClientState::vaEnum[ii][0] ); |
| checkPpcaDefaults(ctx, ppca); |
| } |
| else |
| { |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0 + ii - 7; |
| ppca.glEnableClientState( Regal::ClientState::vaEnum[7][0] ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0; |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0 + ii - 7; |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableClientState( Regal::ClientState::vaEnum[7][0] ); |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| |
| // test glEnableClientStateiEXT & glDisableClientStateiEXT with no vertex array bound |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| if (ii < 7) |
| { |
| ppca.glEnableClientStateiEXT( Regal::ClientState::vaEnum[ii][0], 0 ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableClientStateiEXT( Regal::ClientState::vaEnum[ii][0], 0 ); |
| checkPpcaDefaults(ctx, ppca); |
| } |
| else |
| { |
| ppca.glEnableClientStateiEXT( Regal::ClientState::vaEnum[7][0], ii - 7 ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableClientStateiEXT( Regal::ClientState::vaEnum[7][0], ii - 7 ); |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| |
| // test glEnableClientStateIndexedEXT & glDisableClientStateIndexedEXT with no vertex array bound |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| if (ii < 7) |
| { |
| ppca.glEnableClientStateIndexedEXT( Regal::ClientState::vaEnum[ii][0], 0 ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableClientStateIndexedEXT( Regal::ClientState::vaEnum[ii][0], 0 ); |
| checkPpcaDefaults(ctx, ppca); |
| } |
| else |
| { |
| ppca.glEnableClientStateIndexedEXT( Regal::ClientState::vaEnum[7][0], ii - 7 ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableClientStateIndexedEXT( Regal::ClientState::vaEnum[7][0], ii - 7 ); |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| |
| // test glEnableClientState & glDisableClientState with a vertex array bound |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 1; |
| |
| if (ii < 7) |
| { |
| ppca.glEnableClientState( Regal::ClientState::vaEnum[ii][0] ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableClientState( Regal::ClientState::vaEnum[ii][0] ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| else |
| { |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0 + ii - 7; |
| ppca.glEnableClientState( Regal::ClientState::vaEnum[7][0] ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0 + ii - 7; |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableClientState( Regal::ClientState::vaEnum[7][0] ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| |
| // test glEnableClientStateiEXT & glDisableClientStateiEXT with a vertex array bound |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 1; |
| |
| if (ii < 7) |
| { |
| ppca.glEnableClientStateiEXT( Regal::ClientState::vaEnum[ii][0], 0 ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableClientStateiEXT( Regal::ClientState::vaEnum[ii][0], 0 ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| else |
| { |
| ppca.glEnableClientStateiEXT( Regal::ClientState::vaEnum[7][0], ii - 7 ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableClientStateiEXT( Regal::ClientState::vaEnum[7][0], ii - 7 ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| |
| // test glEnableClientStateIndexedEXT & glDisableClientStateIndexedEXT with a vertex array bound |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 1; |
| |
| if (ii < 7) |
| { |
| ppca.glEnableClientStateIndexedEXT( Regal::ClientState::vaEnum[ii][0], 0 ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableClientStateIndexedEXT( Regal::ClientState::vaEnum[ii][0], 0 ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| else |
| { |
| ppca.glEnableClientStateIndexedEXT( Regal::ClientState::vaEnum[7][0], ii - 7 ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableClientStateIndexedEXT( Regal::ClientState::vaEnum[7][0], ii - 7 ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| } |
| |
| TEST ( RegalPpca, glBindVertexArray_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glBindVertexArray( GLuint(13579) ); |
| EXPECT_EQ( GLuint(13579), ppca.VertexArray::vertexArrayBinding ); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| TEST ( RegalPpca, glEnableDisableVertexAttribArray_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test glEnableVertexAttribArray & glDisableVertexAttribArray with no vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| ppca.glEnableVertexAttribArray( ii ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].enabled ); |
| ppca.VertexArray::generic[ii].enabled = GL_FALSE; |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].enabled = GL_TRUE; |
| ppca.glDisableVertexAttribArray( ii ); |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| // test glEnableVertexAttribArray & glDisableVertexAttribArray with a vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 1; |
| |
| ppca.glEnableVertexAttribArray( ii ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].enabled ); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.VertexArray::generic[ii].enabled = GL_TRUE; |
| ppca.glDisableVertexAttribArray( ii ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].enabled ); |
| ppca.VertexArray::generic[ii].enabled = GL_FALSE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| |
| TEST ( RegalPpca, glEnableDisableVertexArrayAttribEXT_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test glEnableVertexArrayAttribEXT & glDisableVertexArrayAttribEXT with no vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glEnableVertexArrayAttribEXT( 0, ii ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].enabled ); |
| ppca.VertexArray::generic[ii].enabled = GL_FALSE; |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].enabled = GL_TRUE; |
| ppca.glDisableVertexArrayAttribEXT( 0, ii ); |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| // test glEnableVertexAttribArray & glDisableVertexAttribArray with a vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.glEnableVertexArrayAttribEXT( ii+1, ii ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].enabled ); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].enabled = GL_TRUE; |
| ppca.glDisableVertexArrayAttribEXT( ii+1, ii ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].enabled ); |
| ppca.VertexArray::generic[ii].enabled = GL_FALSE; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| |
| TEST ( RegalPpca, glEnableDisableVertexArrayEXT_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test glEnableVertexArrayEXT & glDisableVertexArrayEXT with no vertex array object |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| if (ii < 7) |
| { |
| ppca.glEnableVertexArrayEXT( 0, Regal::ClientState::vaEnum[ii][0] ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableVertexArrayEXT( 0, Regal::ClientState::vaEnum[ii][0] ); |
| checkPpcaDefaults(ctx, ppca); |
| } |
| else |
| { |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0 + ii - 7; |
| ppca.glEnableVertexArrayEXT( 0, Regal::ClientState::vaEnum[7][0] ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0; |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0 + ii - 7; |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableVertexArrayEXT( 0, Regal::ClientState::vaEnum[7][0] ); |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| |
| // test glEnableVertexArrayEXT & glDisableVertexArrayEXT with a vertex array object |
| |
| for (GLuint ii=0; ii<ClientState::nNamedArrays; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| if (ii < 7) |
| { |
| ppca.glEnableVertexArrayEXT( ii+1, Regal::ClientState::vaEnum[ii][0] ); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableVertexArrayEXT( ii+1, Regal::ClientState::vaEnum[ii][0] ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| else |
| { |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0 + ii - 7; |
| ppca.glEnableVertexArrayEXT( ii+1, Regal::ClientState::vaEnum[7][0] ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0; |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0 + ii - 7; |
| ppca.VertexArray::named[ii].enabled = GL_TRUE; |
| ppca.glDisableVertexArrayEXT( ii+1, Regal::ClientState::vaEnum[7][0] ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::named[ii].enabled ); |
| ppca.VertexArray::named[ii].enabled = GL_FALSE; |
| ppca.VertexArray::clientActiveTexture = GL_TEXTURE0; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| } |
| |
| TEST ( RegalPpca, glVertexAttribBinding_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test glVertexAttribBinding with no vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| ppca.glVertexAttribBinding( ii, ii+1 ); |
| EXPECT_EQ( GLuint(ii+1), ppca.VertexArray::generic[ii].bindingIndex ); |
| ppca.VertexArray::generic[ii].bindingIndex = ii; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| // test glVertexAttribBinding with a vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 1; |
| |
| ppca.VertexArray::generic[ii].bindingIndex = ii+1; |
| ppca.glVertexAttribBinding( ii, 0 ); |
| EXPECT_EQ( GLuint(ii+1), ppca.VertexArray::generic[ii].bindingIndex ); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.VertexArray::generic[ii].bindingIndex = ii; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| |
| TEST ( RegalPpca, glVertexBindingDivisor_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test glVertexBindingDivisor with no vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| ppca.glVertexBindingDivisor( ii, 333 ); |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].divisor ); |
| ppca.VertexArray::bindings[ii].divisor = 0; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| // test glVertexBindingDivisor with a vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 1; |
| |
| ppca.VertexArray::bindings[ii].divisor = 333; |
| ppca.glVertexBindingDivisor( ii, 555 ); |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].divisor ); |
| ppca.VertexArray::bindings[ii].divisor = 0; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| // test glVertexAttribDivisor with no vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| if (ii<REGAL_EMU_MAX_VERTEX_ATTRIBS) |
| { |
| ppca.glVertexAttribDivisor( ii, 555 ); |
| EXPECT_EQ( GLuint(555), ppca.VertexArray::bindings[ii].divisor ); |
| EXPECT_EQ( GLuint(ii), ppca.VertexArray::generic[ii].bindingIndex ); |
| ppca.VertexArray::bindings[ii].divisor = 0; |
| ppca.VertexArray::generic[ii].bindingIndex = ii; |
| } |
| else |
| { |
| ppca.VertexArray::bindings[ii].divisor = 333; |
| ppca.glVertexAttribDivisor( ii, 555 ); |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].divisor ); |
| ppca.VertexArray::bindings[ii].divisor = 0; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| } |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| // test glVertexAttribDivisor with a vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 1; |
| |
| if (ii<REGAL_EMU_MAX_VERTEX_ATTRIBS) |
| { |
| ppca.VertexArray::bindings[ii].divisor = 333; |
| ppca.VertexArray::generic[ii].bindingIndex = 333; |
| ppca.glVertexAttribDivisor( ii, 555 ); |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].divisor ); |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::generic[ii].bindingIndex ); |
| ppca.VertexArray::bindings[ii].divisor = 0; |
| ppca.VertexArray::generic[ii].bindingIndex = ii; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| } |
| else |
| { |
| ppca.VertexArray::bindings[ii].divisor = 333; |
| ppca.glVertexAttribDivisor( ii, 555 ); |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].divisor ); |
| ppca.VertexArray::bindings[ii].divisor = 0; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| } |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| |
| TEST ( RegalPpca, glBindVertexBuffer_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test glBindVertexBuffer with no vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| ppca.glBindVertexBuffer( ii, GLuint(2 * ii + 1), GLintptr(0xbeef), ii+3 ); |
| |
| EXPECT_EQ( GLuint(2 * ii + 1), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr( 0xbeef), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(ii + 3), ppca.VertexArray::bindings[ii].stride ); |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| // test glBindVertexBuffer with a vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| ppca.VertexArray::vertexArrayBinding = 1; |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(333); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0xdead); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(11); |
| |
| ppca.glBindVertexBuffer( ii, 1, 1, 1 ); |
| |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr(0xdead), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(11), ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::vertexArrayBinding = GLuint(0); |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| |
| TEST ( RegalPpca, glBindVertexBuffers_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| GLuint buffers[REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS]; |
| GLintptr offsets[REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS]; |
| GLsizei strides[REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS]; |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| buffers[ii] = GLuint(2 * ii + 1); |
| offsets[ii] = GLintptr(0xbeef); |
| strides[ii] = GLsizei(ii+3); |
| } |
| |
| // first test with "real" buffers, offsets, and strides |
| |
| // test glBindVertexBuffers with no vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glBindVertexBuffers( 0, REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS, buffers, offsets, strides ); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| EXPECT_EQ( GLuint(2 * ii + 1), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr( 0xbeef), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(ii + 3), ppca.VertexArray::bindings[ii].stride ); |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| } |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test glBindVertexBuffers with a vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.VertexArray::bindings[ii].buffer = GLuint(333); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0xdead); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(11); |
| } |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glBindVertexBuffers( 0, REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS, buffers, offsets, strides ); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr(0xdead), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(11), ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| } |
| ppca.VertexArray::vertexArrayBinding = GLuint(0); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test partial glBindVertexBuffers with no vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glBindVertexBuffers( 5, REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS-5, &(buffers[5]), &(offsets[5]), &(strides[5]) ); |
| |
| for (GLuint ii=5; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| EXPECT_EQ( GLuint(2 * ii + 1), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr( 0xbeef), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(ii + 3), ppca.VertexArray::bindings[ii].stride ); |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| } |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test partial glBindVertexBuffers with a vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=5; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.VertexArray::bindings[ii].buffer = GLuint(333); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0xdead); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(11); |
| } |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glBindVertexBuffers( 5, REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS-5, &(buffers[5]), &(offsets[5]), &(strides[5]) ); |
| |
| for (GLuint ii=5; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr(0xdead), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(11), ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| } |
| ppca.VertexArray::vertexArrayBinding = GLuint(0); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // a second partial test glBindVertexBuffers with no vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glBindVertexBuffers( 3, 3, &(buffers[3]), &(offsets[3]), &(strides[3]) ); |
| |
| for (GLuint ii=3; ii<6; ii++) |
| { |
| EXPECT_EQ( GLuint(2 * ii + 1), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr( 0xbeef), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(ii + 3), ppca.VertexArray::bindings[ii].stride ); |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| } |
| checkPpcaDefaults(ctx, ppca); |
| |
| // a second partial test glBindVertexBuffers with a vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=3; ii<6; ii++) |
| { |
| ppca.VertexArray::bindings[ii].buffer = GLuint(333); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0xdead); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(11); |
| } |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glBindVertexBuffers( 3, 3, &(buffers[3]), &(offsets[3]), &(strides[3]) ); |
| |
| for (GLuint ii=3; ii<6; ii++) |
| { |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr(0xdead), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(11), ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| } |
| ppca.VertexArray::vertexArrayBinding = GLuint(0); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // a third partial test glBindVertexBuffers with no vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glBindVertexBuffers( 0, 4, buffers, offsets, strides ); |
| |
| for (GLuint ii=0; ii<4; ii++) |
| { |
| EXPECT_EQ( GLuint(2 * ii + 1), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr( 0xbeef), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(ii + 3), ppca.VertexArray::bindings[ii].stride ); |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| } |
| checkPpcaDefaults(ctx, ppca); |
| |
| // a third partial test glBindVertexBuffers with a vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=0; ii<4; ii++) |
| { |
| ppca.VertexArray::bindings[ii].buffer = GLuint(333); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0xdead); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(11); |
| } |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glBindVertexBuffers( 0, 4, buffers, offsets, strides ); |
| |
| for (GLuint ii=0; ii<4; ii++) |
| { |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr(0xdead), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(11), ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| } |
| ppca.VertexArray::vertexArrayBinding = GLuint(0); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // now test passing NULL for buffers |
| |
| // test glBindVertexBuffers with no vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.VertexArray::bindings[ii].buffer = GLuint(333); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0xdead); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(11); |
| } |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glBindVertexBuffers( 0, REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS, NULL, offsets, strides ); |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test glBindVertexBuffers with a vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.VertexArray::bindings[ii].buffer = GLuint(333); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0xdead); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(11); |
| } |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glBindVertexBuffers( 0, REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS, NULL, offsets, strides ); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr(0xdead), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(11), ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| } |
| ppca.VertexArray::vertexArrayBinding = GLuint(0); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test partial glBindVertexBuffers with no vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.VertexArray::bindings[ii].buffer = GLuint(333); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0xdead); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(11); |
| } |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glBindVertexBuffers( 5, REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS-5, NULL, &(offsets[5]), &(strides[5]) ); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| if (ii < 5) |
| { |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr(0xdead), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(11), ppca.VertexArray::bindings[ii].stride ); |
| } |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| } |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test partial glBindVertexBuffers with a vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.VertexArray::bindings[ii].buffer = GLuint(333); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0xdead); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(11); |
| } |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glBindVertexBuffers( 5, REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS-5, NULL, &(offsets[5]), &(strides[5]) ); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr(0xdead), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(11), ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| } |
| ppca.VertexArray::vertexArrayBinding = GLuint(0); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // a second partial test glBindVertexBuffers with no vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.VertexArray::bindings[ii].buffer = GLuint(333); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0xdead); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(11); |
| } |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glBindVertexBuffers( 3, 3, NULL, &(offsets[3]), &(strides[3]) ); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| if (ii >= 3 && ii < 6) |
| { |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr(0), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(16), ppca.VertexArray::bindings[ii].stride ); |
| } |
| else |
| { |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr(0xdead), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(11), ppca.VertexArray::bindings[ii].stride ); |
| } |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| } |
| checkPpcaDefaults(ctx, ppca); |
| |
| // a second partial test glBindVertexBuffers with a vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.VertexArray::bindings[ii].buffer = GLuint(333); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0xdead); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(11); |
| } |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glBindVertexBuffers( 3, 3, NULL, &(offsets[3]), &(strides[3]) ); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr(0xdead), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(11), ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| } |
| ppca.VertexArray::vertexArrayBinding = GLuint(0); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // a third partial test glBindVertexBuffers with no vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.VertexArray::bindings[ii].buffer = GLuint(333); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0xdead); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(11); |
| } |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glBindVertexBuffers( 0, 4, NULL, offsets, strides ); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| if (ii < 4) |
| { |
| EXPECT_EQ( GLuint(0), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr(0), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(16), ppca.VertexArray::bindings[ii].stride ); |
| } |
| else |
| { |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr(0xdead), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(11), ppca.VertexArray::bindings[ii].stride ); |
| } |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| } |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| // a third partial test glBindVertexBuffers with a vertex array bound |
| |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.VertexArray::bindings[ii].buffer = GLuint(333); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0xdead); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(11); |
| } |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glBindVertexBuffers( 0, 4, NULL, offsets, strides ); |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| EXPECT_EQ( GLuint(333), ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( GLintptr(0xdead), ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( GLsizei(11), ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| } |
| ppca.VertexArray::vertexArrayBinding = GLuint(0); |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| TEST ( RegalPpca, glVertexAttribFormat_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test glVertexAttrib(I|L|)Format with no vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glVertexAttribIFormat( ii, GLuint(2 * ii + 1), GLenum(ii), GLuint(ii + 3) ); |
| |
| EXPECT_EQ( GLuint(2 * ii + 1), ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( GLenum(ii), ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint(ii + 3), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isLong ); |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glVertexAttribLFormat( ii, GLuint(2 * ii + 1), GLenum(ii), ii + 3 ); |
| |
| EXPECT_EQ( GLuint(2 * ii + 1), ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( GLenum(ii), ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint(ii + 3), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isLong ); |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.glVertexAttribFormat( ii, GLuint(2 * ii + 1), GLenum(ii), GL_TRUE, ii + 3 ); |
| |
| EXPECT_EQ( GLuint(2 * ii + 1), ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( GLenum(ii), ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint(ii + 3), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isLong ); |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.VertexArray::generic[ii].normalized = GL_TRUE; |
| ppca.glVertexAttribFormat( ii, GLuint(2 * ii + 1), GLenum(ii), GL_FALSE, ii + 3 ); |
| |
| EXPECT_EQ( GLuint(2 * ii + 1), ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( GLenum(ii), ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint(ii + 3), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isLong ); |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| // test glVertexAttrib(I|L|)Format with a vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].size = 2 * ii + 3; |
| ppca.VertexArray::generic[ii].type = GLenum(2 * ii + 4); |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(2 * ii + 5); |
| ppca.VertexArray::generic[ii].normalized = GL_TRUE; |
| ppca.VertexArray::generic[ii].isInteger = GL_TRUE; |
| ppca.VertexArray::generic[ii].isLong = GL_TRUE; |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glVertexAttribIFormat( ii, ii + 1, GLenum(ii + 2), ii + 3 ); |
| |
| EXPECT_EQ( GLuint(2 * ii + 3), ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( GLenum(2 * ii + 4), ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint(2 * ii + 5), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isLong ); |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].size = 2 * ii + 3; |
| ppca.VertexArray::generic[ii].type = GLenum(2 * ii + 4); |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(2 * ii + 5); |
| ppca.VertexArray::generic[ii].normalized = GL_TRUE; |
| ppca.VertexArray::generic[ii].isInteger = GL_TRUE; |
| ppca.VertexArray::generic[ii].isLong = GL_TRUE; |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glVertexAttribLFormat( ii, ii + 1, GLenum(ii + 2), ii + 3 ); |
| |
| EXPECT_EQ( GLuint(2 * ii + 3), ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( GLenum(2 * ii + 4), ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint(2 * ii + 5), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isLong ); |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].size = 2 * ii + 3; |
| ppca.VertexArray::generic[ii].type = GLenum(2 * ii + 4); |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(2 * ii + 5); |
| ppca.VertexArray::generic[ii].normalized = GL_TRUE; |
| ppca.VertexArray::generic[ii].isInteger = GL_TRUE; |
| ppca.VertexArray::generic[ii].isLong = GL_TRUE; |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glVertexAttribFormat( ii, ii + 1, GLenum(ii + 2), GL_FALSE, ii + 3 ); |
| |
| EXPECT_EQ( GLuint(2 * ii + 3), ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( GLenum(2 * ii + 4), ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint(2 * ii + 5), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isLong ); |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].size = 2 * ii + 3; |
| ppca.VertexArray::generic[ii].type = GLenum(2 * ii + 4); |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(2 * ii + 5); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_TRUE; |
| ppca.VertexArray::generic[ii].isLong = GL_TRUE; |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glVertexAttribFormat( ii, ii + 1, GLenum(ii + 2), GL_TRUE, ii + 3 ); |
| |
| EXPECT_EQ( GLuint(2 * ii + 3), ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( GLenum(2 * ii + 4), ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint(2 * ii + 5), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isLong ); |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| |
| TEST ( RegalPpca, glVertexAttribPointer_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test glVertexAttrib(I|L|)Pointer with no vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS && ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| GLuint testSize = GLuint(2 * ii + 1); |
| GLenum testType = GLenum(ii); |
| GLsizei testStride = GLsizei(ii + 3); |
| GLintptr testOffset = (GLintptr)(ii + 4); |
| GLuint testBuffer = ppca.VertexArray::arrayBufferBinding; |
| |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glVertexAttribIPointer( ii, testSize, testType, testStride, reinterpret_cast<const GLvoid*>(testOffset) ); |
| |
| EXPECT_EQ( testSize, ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( testType, ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint( 0 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isLong ); |
| EXPECT_EQ( ii, ppca.VertexArray::generic[ii].bindingIndex ); |
| |
| EXPECT_EQ( testBuffer, ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( testOffset, ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( testStride, ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::generic[ii].bindingIndex = ii; |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glVertexAttribLPointer( ii, testSize, testType, testStride, reinterpret_cast<const GLvoid*>(testOffset) ); |
| |
| EXPECT_EQ( testSize, ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( testType, ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint( 0 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isLong ); |
| EXPECT_EQ( ii, ppca.VertexArray::generic[ii].bindingIndex ); |
| |
| EXPECT_EQ( testBuffer, ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( testOffset, ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( testStride, ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::generic[ii].bindingIndex = ii; |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| ppca.VertexArray::generic[ii].normalized = GL_TRUE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glVertexAttribPointer( ii, testSize, testType, GL_FALSE, testStride, reinterpret_cast<const GLvoid*>(testOffset) ); |
| |
| EXPECT_EQ( testSize, ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( testType, ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint( 0 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isLong ); |
| EXPECT_EQ( ii, ppca.VertexArray::generic[ii].bindingIndex ); |
| |
| EXPECT_EQ( testBuffer, ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( testOffset, ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( testStride, ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::generic[ii].bindingIndex = ii; |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glVertexAttribPointer( ii, testSize, testType, GL_TRUE, testStride, reinterpret_cast<const GLvoid*>(testOffset) ); |
| |
| EXPECT_EQ( testSize, ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( testType, ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint( 0 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isLong ); |
| EXPECT_EQ( ii, ppca.VertexArray::generic[ii].bindingIndex ); |
| |
| EXPECT_EQ( testBuffer, ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( testOffset, ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( testStride, ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::generic[ii].bindingIndex = ii; |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| // test glVertexAttrib(I|L|)Pointer with a vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS && ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| GLuint testSize = GLuint(2 * ii + 1); |
| GLenum testType = GLenum(ii); |
| GLsizei testStride = GLsizei(ii + 3); |
| GLintptr testOffset = (GLintptr)(ii + 4); |
| |
| ppca.VertexArray::generic[ii].normalized = GL_TRUE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_TRUE; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glVertexAttribIPointer( ii, testSize, testType, testStride, reinterpret_cast<const GLvoid*>(testOffset) ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::vertexArrayBinding ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isLong ); |
| |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].normalized = GL_TRUE; |
| ppca.VertexArray::generic[ii].isInteger = GL_TRUE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glVertexAttribLPointer( ii, testSize, testType, testStride, reinterpret_cast<const GLvoid*>(testOffset) ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::vertexArrayBinding ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isLong ); |
| |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].normalized = GL_TRUE; |
| ppca.VertexArray::generic[ii].isInteger = GL_TRUE; |
| ppca.VertexArray::generic[ii].isLong = GL_TRUE; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glVertexAttribPointer( ii, testSize, testType, GL_FALSE, testStride, reinterpret_cast<const GLvoid*>(testOffset) ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::vertexArrayBinding ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isLong ); |
| |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_TRUE; |
| ppca.VertexArray::generic[ii].isLong = GL_TRUE; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glVertexAttribPointer( ii, testSize, testType, GL_TRUE, testStride, reinterpret_cast<const GLvoid*>(testOffset) ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::vertexArrayBinding ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isLong ); |
| |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| |
| TEST ( RegalPpca, glVertexArrayVertexAttribOffsetEXT_Shadowing ) |
| { |
| RegalContext ctx; |
| ctx.info = new ContextInfo(); |
| |
| Ppca ppca; |
| ppca.Init(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| // test glVertexArrayVertexAttrib(I|)OffsetEXT with no vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS && ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| GLuint testSize = GLuint(2 * ii + 1); |
| GLenum testType = GLenum(ii); |
| GLsizei testStride = GLsizei(ii + 3); |
| GLintptr testOffset = (GLintptr)(ii + 4); |
| GLuint testBuffer = ppca.VertexArray::arrayBufferBinding + 1; |
| |
| // first test passing in 0 for vertex array object |
| |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glVertexArrayVertexAttribIOffsetEXT( 0, testBuffer, ii, testSize, testType, testStride, testOffset ); |
| |
| EXPECT_EQ( testSize, ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( testType, ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint( 0 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isLong ); |
| EXPECT_EQ( ii, ppca.VertexArray::generic[ii].bindingIndex ); |
| |
| EXPECT_EQ( testBuffer, ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( testOffset, ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( testStride, ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::generic[ii].bindingIndex = ii; |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| ppca.VertexArray::generic[ii].normalized = GL_TRUE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glVertexArrayVertexAttribOffsetEXT( 0, testBuffer, ii, testSize, testType, GL_FALSE, testStride, testOffset ); |
| |
| EXPECT_EQ( testSize, ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( testType, ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint( 0 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isLong ); |
| EXPECT_EQ( ii, ppca.VertexArray::generic[ii].bindingIndex ); |
| |
| EXPECT_EQ( testBuffer, ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( testOffset, ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( testStride, ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::generic[ii].bindingIndex = ii; |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glVertexArrayVertexAttribOffsetEXT( 0, testBuffer, ii, testSize, testType, GL_TRUE, testStride, testOffset ); |
| |
| EXPECT_EQ( testSize, ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( testType, ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint( 0 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isLong ); |
| EXPECT_EQ( ii, ppca.VertexArray::generic[ii].bindingIndex ); |
| |
| EXPECT_EQ( testBuffer, ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( testOffset, ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( testStride, ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::generic[ii].bindingIndex = ii; |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| // now test passing in 1 for vertex array object |
| |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glVertexArrayVertexAttribIOffsetEXT( 1, testBuffer, ii, testSize, testType, testStride, testOffset ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| |
| ppca.VertexArray::generic[ii].relativeOffset = 0; |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| ppca.VertexArray::generic[ii].normalized = GL_TRUE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glVertexArrayVertexAttribOffsetEXT( 1, testBuffer, ii, testSize, testType, GL_FALSE, testStride, testOffset ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].normalized ); |
| |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::vertexArrayBinding = 0; |
| ppca.glVertexArrayVertexAttribOffsetEXT( 1, testBuffer, ii, testSize, testType, GL_TRUE, testStride, testOffset ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].normalized ); |
| |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| |
| checkPpcaDefaults(ctx, ppca); |
| } |
| |
| // test glVertexArrayVertexAttrib(I|)OffsetEXT with a vertex array bound |
| |
| for (GLuint ii=0; ii<REGAL_EMU_MAX_VERTEX_ATTRIBS && ii<REGAL_EMU_MAX_VERTEX_ATTRIB_BINDINGS; ii++) |
| { |
| ppca.Reset(ctx); |
| checkPpcaDefaults(ctx, ppca); |
| |
| GLuint testSize = GLuint(2 * ii + 1); |
| GLenum testType = GLenum(ii); |
| GLsizei testStride = GLsizei(ii + 3); |
| GLintptr testOffset = (GLintptr)(ii + 4); |
| GLuint testBuffer = ppca.VertexArray::arrayBufferBinding + 1; |
| |
| // first test passing in 0 for vertex array object |
| |
| ppca.VertexArray::generic[ii].normalized = GL_TRUE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_TRUE; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glVertexArrayVertexAttribIOffsetEXT( 0, testBuffer, ii, testSize, testType, testStride, testOffset ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::vertexArrayBinding ); |
| |
| EXPECT_EQ( testSize, ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( testType, ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint( 0 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isLong ); |
| EXPECT_EQ( ii, ppca.VertexArray::generic[ii].bindingIndex ); |
| |
| EXPECT_EQ( testBuffer, ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( testOffset, ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( testStride, ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::generic[ii].bindingIndex = ii; |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].normalized = GL_TRUE; |
| ppca.VertexArray::generic[ii].isInteger = GL_TRUE; |
| ppca.VertexArray::generic[ii].isLong = GL_TRUE; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glVertexArrayVertexAttribOffsetEXT( 0, testBuffer, ii, testSize, testType, GL_FALSE, testStride, testOffset ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::vertexArrayBinding ); |
| |
| EXPECT_EQ( testSize, ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( testType, ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint( 0 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isLong ); |
| EXPECT_EQ( ii, ppca.VertexArray::generic[ii].bindingIndex ); |
| |
| EXPECT_EQ( testBuffer, ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( testOffset, ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( testStride, ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::generic[ii].bindingIndex = ii; |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_TRUE; |
| ppca.VertexArray::generic[ii].isLong = GL_TRUE; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glVertexArrayVertexAttribOffsetEXT( 0, testBuffer, ii, testSize, testType, GL_TRUE, testStride, testOffset ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::vertexArrayBinding ); |
| |
| EXPECT_EQ( testSize, ppca.VertexArray::generic[ii].size ); |
| EXPECT_EQ( testType, ppca.VertexArray::generic[ii].type ); |
| EXPECT_EQ( GLuint( 0 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isLong ); |
| EXPECT_EQ( ii, ppca.VertexArray::generic[ii].bindingIndex ); |
| |
| EXPECT_EQ( testBuffer, ppca.VertexArray::bindings[ii].buffer ); |
| EXPECT_EQ( testOffset, ppca.VertexArray::bindings[ii].offset ); |
| EXPECT_EQ( testStride, ppca.VertexArray::bindings[ii].stride ); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| ppca.VertexArray::generic[ii].size = 4; |
| ppca.VertexArray::generic[ii].type = GL_FLOAT; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| ppca.VertexArray::generic[ii].bindingIndex = ii; |
| |
| ppca.VertexArray::bindings[ii].buffer = GLuint(0); |
| ppca.VertexArray::bindings[ii].offset = GLintptr(0); |
| ppca.VertexArray::bindings[ii].stride = GLsizei(16); |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| // now test passing in 1 for vertex array object |
| |
| ppca.VertexArray::generic[ii].normalized = GL_TRUE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_TRUE; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glVertexArrayVertexAttribIOffsetEXT( 1, testBuffer, ii, testSize, testType, testStride, testOffset ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::vertexArrayBinding ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isLong ); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].normalized = GL_TRUE; |
| ppca.VertexArray::generic[ii].isInteger = GL_TRUE; |
| ppca.VertexArray::generic[ii].isLong = GL_TRUE; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| ppca.glVertexArrayVertexAttribOffsetEXT( 1, testBuffer, ii, testSize, testType, GL_FALSE, testStride, testOffset ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::vertexArrayBinding ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isLong ); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| |
| checkPpcaDefaults(ctx, ppca); |
| |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_TRUE; |
| ppca.VertexArray::generic[ii].isLong = GL_TRUE; |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(1); |
| |
| ppca.VertexArray::vertexArrayBinding = 1; |
| |
| ppca.glVertexArrayVertexAttribOffsetEXT( 1, testBuffer, ii, testSize, testType, GL_TRUE, testStride, testOffset ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::vertexArrayBinding ); |
| |
| EXPECT_EQ( GLuint( 1 ), ppca.VertexArray::generic[ii].relativeOffset ); |
| EXPECT_EQ( GLboolean(GL_FALSE), ppca.VertexArray::generic[ii].normalized ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isInteger ); |
| EXPECT_EQ( GLboolean(GL_TRUE), ppca.VertexArray::generic[ii].isLong ); |
| |
| ppca.VertexArray::vertexArrayBinding = 0; |
| |
| ppca.VertexArray::generic[ii].relativeOffset = GLuint(0); |
| ppca.VertexArray::generic[ii].normalized = GL_FALSE; |
| ppca.VertexArray::generic[ii].isInteger = GL_FALSE; |
| ppca.VertexArray::generic[ii].isLong = GL_FALSE; |
| |
| checkPpcaDefaults(ctx, ppca); |
| } |
| } |
| |
| } // namespace |
| |
| /* |
| glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) |
| */ |