/**************************************************************************** ** InitView() is called by PVRShell each time a rendering variable is changed ** in the Shell menu (Z-Buffer On/Off, resolution change, buffering mode...) ** In this function one should initialise all variables that are dependant on ** general rendering variables (screen mode, 3D device, etc...) ****************************************************************************/ bool OVGFont::InitView() { CPVRTPVGObject* pPVGObj; VGImage vgImage; VGImage vgChild; float fW,fH; PVRTVECTOR2 fGlyphOrigin, fEscapement; // Store the screen width and height m_ui32ScreenWidth = PVRShellGet(prefWidth); m_ui32ScreenHeight = PVRShellGet(prefHeight); // Set the clear colour VGfloat afClearColour[] = { 0.6f, 0.8f, 1.0f, 1.0f }; vgSetfv(VG_CLEAR_COLOR, 4, afClearColour); // Initialise PrintVG for the logo and the title m_PrintVG.Initialize(m_ui32ScreenWidth, m_ui32ScreenHeight); // Load the font path data from the pvg file pPVGObj = CPVRTPVGObject::FromFile(c_szPVGFile); if(pPVGObj == NULL) { PVRShellSet(prefExitMessage, "Error: Failed to load Font.pvg."); return false; } if(pPVGObj->m_i32NumPaths != g_i32ImageCharNo) { PVRShellSet(prefExitMessage, "Error: Font.pvg doesn't contain the expected amount of characters."); delete pPVGObj; return false; } // Load the image based font data if(PVRTImageLoadFromPVR(c_szPVRFile, &vgImage) != PVR_SUCCESS) { PVRShellSet(prefExitMessage, "Error: Failed to open mask.pvr."); return false; } /* Create two fonts. m_vgPathFont will purely contain glyphs represented by paths and m_vgImageFont by images. It is also reasonable to have a font that contains a mixture but we are keeping them seperate so they can be compared. */ m_vgImageFont = vgCreateFont(g_i32ImageCharNo); m_vgPathFont = vgCreateFont(pPVGObj->m_i32NumPaths); // Add the glyphs to the fonts. for(int i = 0; i < g_i32ImageCharNo; ++i) { // Load glyph from path data /* Each path in the PVG file represents a glyph. First we need to acquire the origin of the glyph so we use vgPathBounds to achieve this as the origin described in g_CharDesc is for the image. */ vgPathBounds(pPVGObj->m_pPaths[i].m_path, &fGlyphOrigin.x, &fGlyphOrigin.y, &fW, &fH); // We offset the origin so glyphs like a 'y' are lower fGlyphOrigin.x += g_CharDesc[i].fOriginOffset.x; fGlyphOrigin.y += g_CharDesc[i].fOriginOffset.y; /* Add the glyph and assign it a unique ID. The characters we're loading have ASCII codes ranging from 33 to 128 hence we're giving the glyphs IDs starting at 33. The glyph origin defines the coordinates in path space at which to start drawing the glyph and the escapement character is the offset to start drawing the next following character. */ vgSetGlyphToPath(m_vgPathFont, 33 + i, pPVGObj->m_pPaths[i].m_path, VG_TRUE, (VGfloat*) &fGlyphOrigin.x, (VGfloat*) &g_CharDesc[i].fEscapement.x); // Load glyph from image data /* Using a child image we 'cut' the glyph out of the main image (see the child image training course for an explanation). */ vgChild = vgChildImage(vgImage, g_CharDesc[i].i32Origin[0], g_CharDesc[i].i32Origin[1], g_CharDesc[i].i32Width, g_CharDesc[i].i32Height); /* We then add the child image to the font. We use the origin offset value directly for the value as the glyph's origin is 0,0 within the child image. */ vgSetGlyphToImage(m_vgImageFont, 33 + i, vgChild, (VGfloat*) &g_CharDesc[i].fOriginOffset.x, (VGfloat*) &g_CharDesc[i].fEscapement.x); // Destroy the child image as we no longer need it. vgDestroyImage(vgChild); } // Destroy the image as it is no longer required vgDestroyImage(vgImage); // Destroy the PVG data as it too is no longer required delete pPVGObj; pPVGObj = 0; // Space /* Glyphs such as spaces that do not have a visual representation can be added to the fonts by passing VG_INVALID_HANDLE instead of a path or image handle. */ // Set the glyph origin and escapement for the space... fGlyphOrigin.x = 0.0f; fGlyphOrigin.y = 0.0f; // ... We're giving the space a width of 10.0f fEscapement.x = 10.0f; fEscapement.y = 0.0f; vgSetGlyphToImage(m_vgImageFont, 32, VG_INVALID_HANDLE, (VGfloat*) &fGlyphOrigin.x, (VGfloat*) &fEscapement.x); vgSetGlyphToPath(m_vgPathFont, 32, VG_INVALID_HANDLE, VG_TRUE, (VGfloat*) &fGlyphOrigin.x, (VGfloat*) &fEscapement.x); // Create font paint m_vgFontPaint = vgCreatePaint(); vgSetParameteri(m_vgFontPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR); vgSetColor(m_vgFontPaint, PVRTRGBA(255,0,0,255)); return true; }
/*!*************************************************************************** @Function DisplayDefaultTitle @Input sTitle Title to display @Input sDescription Description to display @Input uDisplayLogo 1 = Display the logo @Return PVR_SUCCESS or PVR_FAIL @Description Creates a default title with predefined position and colours. It displays as well company logos when requested: 0 = No logo 1 = PowerVR logo 2 = Img Tech logo *****************************************************************************/ EPVRTError CPVRTPrint3D::DisplayDefaultTitle(const char * const pszTitle, const char * const pszDescription, const unsigned int uDisplayLogo) { EPVRTError eRet = PVR_SUCCESS; #if !defined (DISABLE_PRINT3D) // Display Title if(pszTitle) { if(Print3D(0.0f, 0.0f, 1.0f, PVRTRGBA(255, 255, 0, 255), pszTitle) != PVR_SUCCESS) eRet = PVR_FAIL; } // Display Description if(pszDescription) { float fY = (float)(int((m_uiNextLineH / (480.0f/100.0f)) / m_fScreenScale[1])); if(Print3D(0.0f, fY, 0.8f, PVRTRGBA(255, 255, 255, 255), pszDescription) != PVR_SUCCESS) eRet = PVR_FAIL; } m_uLogoToDisplay = uDisplayLogo; #endif return eRet; }
/*!*************************************************************************** @Function DisplayDefaultTitle @Input sTitle Title to display @Input sDescription Description to display @Input uDisplayLogo 1 = Display the logo @Return PVR_SUCCESS or PVR_FAIL @Description Creates a default title with predefined position and colours. It displays as well company logos when requested: 0 = No logo 1 = PowerVR logo 2 = Img Tech logo *****************************************************************************/ EPVRTError CPVRTPrint3D::DisplayDefaultTitle(const char * const pszTitle, const char * const pszDescription, const unsigned int uDisplayLogo) { EPVRTError eRet = PVR_SUCCESS; #if !defined (DISABLE_PRINT3D) // Display Title if(pszTitle) { if(Print3D(0.0f, 1.0f, 1.2f, PVRTRGBA(255, 255, 0, 255), pszTitle) != PVR_SUCCESS) eRet = PVR_FAIL; } // Display Description if(pszDescription) { if(Print3D(0.0f, 8.0f, 0.9f, PVRTRGBA(255, 255, 255, 255), pszDescription) != PVR_SUCCESS) eRet = PVR_FAIL; } m_uLogoToDisplay = uDisplayLogo; #endif return eRet; }
/******************************************************************************* * Function Name : InitView * Inputs : uWidth, uHeight * Returns : true if no error occured * Description : Code in InitView() will be called by the Shell upon a change * in the rendering context. * Used to initialise variables that are dependent on the rendering * context (e.g. textures, vertex buffers, etc.) *******************************************************************************/ bool CTransforms::InitView() { // Create paths CreatePaths(); // Create paint m_vgPaint = vgCreatePaint(); vgSetParameteri(m_vgPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR); vgSetColor(m_vgPaint, PVRTRGBA(255, 255, 170, 255)); vgSeti(VG_STROKE_JOIN_STYLE, VG_JOIN_ROUND); vgSetf(VG_STROKE_LINE_WIDTH, 2.5f / PVRShellGet(prefHeight)); /* The clear colour will be used whenever calling vgClear(). The colour is given as non-premultiplied sRGBA. */ VGfloat afClearColour[] = { 0.6f, 0.8f, 1.0f, 1.0f }; vgSetfv(VG_CLEAR_COLOR, 4, afClearColour); // Initialise custom text drawing m_PrintVG.Initialize(PVRShellGet(prefWidth), PVRShellGet(prefHeight)); m_ui32StartTime = PVRShellGetTime(); return true; }
/*!**************************************************************************** @Function RenderScene @Return bool true if no error occured @Description Main rendering loop function of the program. The shell will call this function every frame. eglSwapBuffers() will be performed by PVRShell automatically. PVRShell will also manage important OS events. Will also manage relevent OS events. The user has access to these events through an abstraction layer provided by PVRShell. ******************************************************************************/ bool OGLES2Fog::RenderScene() { // Clear the color and depth buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Keyboard input (cursor to change fog function) if (PVRShellIsKeyPressed(PVRShellKeyNameLEFT)) { m_eFogMode = EFogMode((m_eFogMode + eNumFogModes - 1) % eNumFogModes); } if (PVRShellIsKeyPressed(PVRShellKeyNameRIGHT)) { m_eFogMode = EFogMode((m_eFogMode + 1) % eNumFogModes); } // Use the loaded shader program glUseProgram(m_ShaderProgram.uiId); // Bind texture glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_uiTexture); // Set uniforms glUniform1i(m_ShaderProgram.uiFogFuncLoc, m_eFogMode); // Rotate and translate the model matrix PVRTMat4 mModel = PVRTMat4::RotationY(m_fAngleY); m_fAngleY += PVRT_PI / 90; mModel.preTranslate(0, 0, 500 * cos(m_fPositionZ) - 450); m_fPositionZ += (2*PVRT_PI)*0.0008f; // Feed Projection and Model View matrices to the shaders PVRTMat4 mModelView = m_mView * mModel; PVRTMat4 mMVP = m_mProjection * mModelView; glUniformMatrix4fv(m_ShaderProgram.uiModelViewLoc, 1, GL_FALSE, mModelView.ptr()); glUniformMatrix4fv(m_ShaderProgram.uiMVPMatrixLoc, 1, GL_FALSE, mMVP.ptr()); // Pass the light direction transformed with the inverse of the ModelView matrix // This saves the transformation of the normals per vertex. A simple dot3 between this direction // and the un-transformed normal will allow proper smooth shading. PVRTVec3 vMsLightDir = (PVRTMat3(mModel).inverse() * PVRTVec3(1, 1, 1)).normalized(); glUniform3fv(m_ShaderProgram.uiLightDirLoc, 1, vMsLightDir.ptr()); /* Now that the model-view matrix is set and the materials ready, call another function to actually draw the mesh. */ DrawMesh(0); // Displays the demo name using the tools. For a detailed explanation, see the training course IntroducingPVRTools m_Print3D.DisplayDefaultTitle("Fog", "", ePVRTPrint3DLogoIMG); m_Print3D.Print3D(0.3f, 7.5f, 0.75f, PVRTRGBA(255,255,255,255), "Fog Mode: %s", g_FogFunctionList[m_eFogMode]); m_Print3D.Flush(); return true; }
/**************************************************************************** ** InitView() is called by PVRShell each time a rendering variable is changed ** in the Shell menu (Z-Buffer On/Off, resolution change, buffering mode...) ** In this function one should initialise all variables that are dependant on ** general rendering variables (screen mode, 3D device, etc...) ****************************************************************************/ bool CIntroducingPVRShell::InitView() { /* Initially, the OpenVG coordinate system is based on the output resolution. To get a device independent coordinate system, we need to apply a transformation. Scaling by the output resolution means that coordinates between (0, 0) and (1, 1) will be visible on screen. It should be noted, however, that different aspect ratios usually require special attention regarding the layout of elements on screen. */ vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE); vgLoadIdentity(); vgScale((float)PVRShellGet(prefWidth), (float)PVRShellGet(prefHeight)); /* Drawing shapes with OpenVG requires a path which represents a series of line and curve segments describing the outline of the shape. The shape does not need to be closed, but for now we will start with a simple triangle. First we create a path object, then we append segment and point data. */ m_vgPath = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 4, 3, (unsigned int)VG_PATH_CAPABILITY_ALL); VGubyte aui8PathSegments[4] = { VG_MOVE_TO_ABS, VG_LINE_TO_ABS, VG_LINE_TO_ABS, VG_CLOSE_PATH, }; VGfloat afPoints[6] = { 0.3f, 0.3f, 0.7f, 0.3f, 0.5f, 0.7f, }; vgAppendPathData(m_vgPath, 4, aui8PathSegments, afPoints); /* To fill a shape, we need a paint that describes how to fill it: a gradient, pattern, or single colour. Here we choose a simple opaque red. */ m_vgFillPaint = vgCreatePaint(); vgSetParameteri(m_vgFillPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR); vgSetColor(m_vgFillPaint, PVRTRGBA(255,255,170,255)); /* The clear colour will be used whenever calling vgClear(). The colour is given as non-premultiplied sRGBA. */ VGfloat afClearColour[] = { 0.6f, 0.8f, 1.0f, 1.0f }; vgSetfv(VG_CLEAR_COLOR, 4, afClearColour); return true; }
/*!*************************************************************************** @fn DisplayDefaultTitle @param[in] sTitle Title to display @param[in] sDescription Description to display @param[in] uDisplayLogo 1 = Display the logo @return PVR_SUCCESS or PVR_FAIL @brief Creates a default title with predefined position and colours. It displays as well company logos when requested: 0 = No logo 1 = PowerVR logo 2 = Img Tech logo *****************************************************************************/ EPVRTError CPVRTPrint3D::DisplayDefaultTitle(const char * const pszTitle, const char * const pszDescription, const unsigned int uDisplayLogo) { EPVRTError eRet = PVR_SUCCESS; #if !defined (DISABLE_PRINT3D) // Display Title if(pszTitle) { if(Print3D(0.0f, -1.0f, 1.0f, PVRTRGBA(255, 255, 255, 255), pszTitle) != PVR_SUCCESS) eRet = PVR_FAIL; } float fYVal; if(m_bRotate) fYVal = m_fScreenScale[0] * 480.0f; else fYVal = m_fScreenScale[1] * 480.0f; // Display Description if(pszDescription) { float fY; float a = 320.0f/fYVal; fY = m_uiNextLineH / (480.0f/100.0f) * a; if(Print3D(0.0f, fY, 0.8f, PVRTRGBA(255, 255, 255, 255), pszDescription) != PVR_SUCCESS) eRet = PVR_FAIL; } m_uLogoToDisplay = uDisplayLogo; #endif return eRet; }
/*!*************************************************************************** @Function CreateDefaultWindow @Input fPosX Position X for the new window @Input fPosY Position Y for the new window @Input nXSize_LettersPerLine @Input sTitle Title of the window @Input sBody Body text of the window @Return Window handle @Description Creates a default window. If Title is NULL the main body will have just one line (for InfoWin). *****************************************************************************/ unsigned int CPVRTPrint3D::CreateDefaultWindow(float fPosX, float fPosY, int nXSize_LettersPerLine, const char * const sTitle, const char * const sBody) { #if !defined (DISABLE_PRINT3D) unsigned int dwActualWin; unsigned int dwFlags = ePVRTPrint3D_ADJUST_SIZE_ALWAYS; unsigned int dwBodyTextColor, dwBodyBackgroundColor; // If no text is specified, return an error if(!sBody && !sTitle) return 0xFFFFFFFF; // If no title is specified, body text colours are different if(!sTitle) { dwBodyTextColor = PVRTRGBA(0xFF, 0xFF, 0x30, 0xFF); dwBodyBackgroundColor = PVRTRGBA(0x20, 0x20, 0xB0, 0xE0); } else { dwBodyTextColor = PVRTRGBA(0xFF, 0xFF, 0xFF, 0xFF); dwBodyBackgroundColor = PVRTRGBA(0x20, 0x30, 0xFF, 0xE0); } // Set window flags depending on title and body text were specified if(!sBody) dwFlags |= ePVRTPrint3D_DEACTIVATE_WIN; if(!sTitle) dwFlags |= ePVRTPrint3D_DEACTIVATE_TITLE; // Create window dwActualWin = InitWindow(nXSize_LettersPerLine, (sTitle==NULL) ? 1:50); // Set window properties SetWindow(dwActualWin, dwBodyBackgroundColor, dwBodyTextColor, 0.5f, fPosX, fPosY, 20.0f, 20.0f); // Set title if (sTitle) SetTitle(dwActualWin, PVRTRGBA(0x20, 0x20, 0xB0, 0xE0), 0.6f, PVRTRGBA(0xFF, 0xFF, 0x30, 0xFF), sTitle, PVRTRGBA(0xFF, 0xFF, 0x30, 0xFF), (char*)""); // Set window text if (sBody) SetText(dwActualWin, sBody); // Set window flags SetWindowFlags(dwActualWin, dwFlags); m_pWin[dwActualWin].bNeedUpdated = true; // Return window handle return dwActualWin; #else return 0; #endif }
/*!**************************************************************************** @Function RenderScene @Return bool true if no error occured @Description Main rendering loop function of the program. The shell will call this function every frame. eglSwapBuffers() will be performed by PVRShell automatically. PVRShell will also manage important OS events. Will also manage relevent OS events. The user has access to these events through an abstraction layer provided by PVRShell. ******************************************************************************/ bool OGLES2AnisotropicLighting::RenderScene() { // Clear the color and depth buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Keyboard input (cursor to change render mode) if (PVRShellIsKeyPressed(PVRShellKeyNameLEFT)) { m_eRenderMode = ERenderMode((m_eRenderMode + eNumRenderModes - 1) % eNumRenderModes); } if (PVRShellIsKeyPressed(PVRShellKeyNameRIGHT)) { m_eRenderMode = ERenderMode((m_eRenderMode + 1) % eNumRenderModes); } // Rotate the model matrix PVRTMat4 mModel = PVRTMat4::RotationY(m_fAngleY); m_fAngleY += 0.02f; // Calculate model view projection matrix PVRTMat4 mMVP = m_mViewProj * mModel; if (m_eRenderMode == eTexLookup) { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_uiTexture); glUseProgram(m_FastShader.uiId); glUniformMatrix4fv(m_FastShader.uiMVPMatrixLoc, 1, GL_FALSE, mMVP.ptr()); /* The inverse of a rotation matrix is the transposed matrix Because of v * M = transpose(M) * v, this means: v * R == inverse(R) * v So we don't have to actually invert or transpose the matrix to transform back from world space to model space */ PVRTVec3 vMsEyePos = PVRTVec3(PVRTVec4(0, 0, 150, 1) * mModel); glUniform3fv(m_FastShader.uiMsEyePosLoc, 1, vMsEyePos.ptr()); PVRTVec3 vMsLightDir = PVRTVec3(PVRTVec4(1, 1, 1, 1) * mModel).normalized(); glUniform3fv(m_FastShader.uiMsLightDirLoc, 1, vMsLightDir.ptr()); } else { glUseProgram(m_SlowShader.uiId); glUniformMatrix4fv(m_SlowShader.uiMVPMatrixLoc, 1, GL_FALSE, mMVP.ptr()); PVRTVec3 vMsEyeDir = PVRTVec3(PVRTVec4(0, 0, 150, 1) * mModel).normalized(); glUniform3fv(m_SlowShader.uiMsEyeDirLoc, 1, vMsEyeDir.ptr()); PVRTVec3 vMsLightDir = PVRTVec3(PVRTVec4(1, 1, 1, 1) * mModel).normalized(); glUniform3fv(m_SlowShader.uiMsLightDirLoc, 1, vMsLightDir.ptr()); } /* Now that the uniforms are set, call another function to actually draw the mesh. */ DrawMesh(0); // Displays the demo name using the tools. For a detailed explanation, see the training course IntroducingPVRTools m_Print3D.DisplayDefaultTitle("AnisotropicLighting", "", ePVRTPrint3DLogoIMG); m_Print3D.Print3D(0.3f, 7.5f, 0.75f, PVRTRGBA(255,255,255,255), c_aszRenderModes[m_eRenderMode]); m_Print3D.Flush(); return true; }
/******************************************************************************* * Function Name : InitView * Returns : true if no error occured * Description : Code in InitView() will be called by the Shell upon a change * in the rendering context. * Used to initialise variables that are dependent on the rendering * context (e.g. textures, vertex buffers, etc.) *******************************************************************************/ bool CChildImage::InitView() { //Create an image m_vgImage = vgCreateImage(VG_sRGBA_8888, IMG_SIZE, IMG_SIZE, VG_IMAGE_QUALITY_NONANTIALIASED); /* Populate the image from memory. A 32bit integer array (8bits per component) is created and populated. */ VGuint* pui32ImgData = new VGuint[IMG_SIZE*IMG_SIZE]; for(int i = 0; i < IMG_SIZE; ++i) { for(int j = 0; j < IMG_SIZE; ++j) { // Fills the data with a fancy pattern if ( ((i*j)/8) % 2 ) pui32ImgData[j*IMG_SIZE+i] = PVRTRGBA(255,255,0,255); else pui32ImgData[j*IMG_SIZE+i] = PVRTRGBA(255, 255 - (j * 2), 255 - i, 255 - (i * 2)); } } /* The data in the array is then copied to the portion of the image starting at (0,0) through to (IMG_SIZE, IMG_SIZE), in this case that is the whole image. The coordinate system of the image places (0,0) at the bottom left-hand corner and (IMG_SIZE, IMG_SIZE) at the top right-hand corner. */ vgImageSubData(m_vgImage, pui32ImgData, sizeof(VGuint) * IMG_SIZE, VG_sRGBA_8888, 0, 0, IMG_SIZE, IMG_SIZE); // Delete the image data as it is now in OpenVG memory delete[] pui32ImgData; pui32ImgData = 0; //Create child images /* The first child is a child of m_vgImage and is made up of the region of m_vgImage from (0,0) to (IMG_SIZE / 2, IMG_SIZE / 2). Note: The area specified must be in the bounds of the parent. */ m_avgChildImages[0] = vgChildImage(m_vgImage, 0, 0, (VGint) (IMG_SIZE * 0.5), (VGint) (IMG_SIZE * 0.5)); //The second child is a clone of the first child. //Get the dimensions of the first child.. int i32ChildWidth = vgGetParameteri(m_avgChildImages[0], VG_IMAGE_WIDTH); int i32ChildHeight= vgGetParameteri(m_avgChildImages[0], VG_IMAGE_HEIGHT); //..and use them to define the region for creating the second child. m_avgChildImages[1] = vgChildImage(m_avgChildImages[0], 0, 0, i32ChildWidth, i32ChildHeight); /* Clear a small portion of the bottom left-hand corner of m_avgChildImages[0] to red. This change will be seen in all relatives of m_avgChildImages[0], reason being they all share the same physical memory. Note: When clearing you specify the coordinate you want to start from and then how many pixels across and up you want to clear. */ VGfloat afClearColour[] = {1.0f, 0.0f, 0.0f, 1.0f}; vgSetfv(VG_CLEAR_COLOR, 4, afClearColour); vgClearImage(m_avgChildImages[0], 0, 0, 10, 10); //Set the clear colour for clearing the sceen afClearColour[0] = 0.6f; afClearColour[1] = 0.8f; afClearColour[2] = 1.0f; afClearColour[3] = 1.0f; vgSetfv(VG_CLEAR_COLOR, 4, afClearColour); m_PrintVG.Initialize(PVRShellGet(prefWidth), PVRShellGet(prefHeight)); return true; }
/******************************************************************************* * Function Name : InitView * Returns : true if no error occured * Description : Code in InitView() will be called by the Shell upon a change * in the rendering context. * Used to initialise variables that are dependent on the rendering * context (e.g. textures, vertex buffers, etc.) *******************************************************************************/ bool OVGMaskLayer::InitView() { // Get screen dimensions m_ui32ScreenWidth = PVRShellGet(prefWidth); m_ui32ScreenHeight= PVRShellGet(prefHeight); // Create the paths so we have something to look at. CreatePath(); // Set the render quality so the stroke borders have some form of anti-aliasing vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_BETTER); // Create the paints that the paths will use m_avgColourPaint[0] = vgCreatePaint(); vgSetParameteri(m_avgColourPaint[0], VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR); vgSetColor(m_avgColourPaint[0], PVRTRGBA(255,255,15,255)); m_avgColourPaint[1] = vgCreatePaint(); vgSetParameteri(m_avgColourPaint[1], VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR); vgSetColor(m_avgColourPaint[1], PVRTRGBA(255,50,0, 255)); m_avgColourPaint[2] = vgCreatePaint(); vgSetParameteri(m_avgColourPaint[2], VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR); vgSetColor(m_avgColourPaint[2], PVRTRGBA(50,250,15, 255)); /* Load the images we're going to use to modify the mask layer. For more details on masking please refer to our OVGMasking training course */ // Create the VGImages. VGImage vgMaskImg, vgMaskImg2; // Using the PVR Tools we're going to load the mask data from a pvr file if(PVRTImageLoadFromPVR(c_szMask1File, &vgMaskImg) != PVR_SUCCESS) { PVRShellSet(prefExitMessage, "Error: Failed to open mask1.pvr."); return false; } if(PVRTImageLoadFromPVR(c_szMask2File, &vgMaskImg2) != PVR_SUCCESS) { PVRShellSet(prefExitMessage, "Error: Failed to open mask2.pvr."); return false; } /* Create a mask layer A VGMaskLayer is an object that allows you to store and manipulate the drawing surface's mask layer */ m_vgMaskLayer[0] = vgCreateMaskLayer(m_ui32ScreenWidth, m_ui32ScreenHeight); if(m_vgMaskLayer[0] == 0) { PVRShellSet(prefExitMessage, "Error: Failed to create mask layer."); return false; } // Tile the first image in the drawing surface's masking layer TileImageInMask(vgMaskImg, VG_SET_MASK); /* Copy the contents of the drawing surface mask layer into our mask layer object vgCopyMask has the following parameters VGMaskLayer maskLayer, VGint dx, VGint dy, VGint sx, VGint sy, VGint width, VGint height) where masklayer is the masklayer to copy to dx, dy are the coordinates to start the copy at in the masklayer sx, sy are the coordinates to start the copy from in the source mask layer width and the height are the width and height of the region you wish to copy. In our case we're copying the full mask layer. */ vgCopyMask(m_vgMaskLayer[0], 0, 0, 0, 0, m_ui32ScreenWidth, m_ui32ScreenHeight); // Create the second mask layer m_vgMaskLayer[1] = vgCreateMaskLayer(m_ui32ScreenWidth, m_ui32ScreenHeight); if(m_vgMaskLayer[1] == 0) { PVRShellSet(prefExitMessage, "Error: Failed to create mask layer."); return false; } // Replace the contents of the mask by tiling the second image TileImageInMask(vgMaskImg2, VG_SET_MASK); // Copy the contents of the mask into the second mask layer vgCopyMask(m_vgMaskLayer[1], 0, 0, 0, 0, m_ui32ScreenWidth, m_ui32ScreenHeight); // Destroy the images as they are no longer needed vgDestroyImage(vgMaskImg); vgDestroyImage(vgMaskImg2); // Set the mask to ones vgMask(VG_INVALID_HANDLE, VG_FILL_MASK, 0, 0, m_ui32ScreenWidth, m_ui32ScreenHeight); // Init PrintVG m_PrintVG.Initialize(m_ui32ScreenWidth, m_ui32ScreenHeight); // Setup the transformation to scale the paths to fit the screen vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE); vgLoadIdentity(); vgScale((float) m_ui32ScreenWidth, (float) m_ui32ScreenHeight); // Reduce the stroke size to compensate for our scaling vgSetf(VG_STROKE_LINE_WIDTH, 1.0f / m_ui32ScreenHeight); //Create and set the clear colour VGfloat afClearColour[] = { 0.6f, 0.8f, 1.0f, 1.0f }; vgSetfv(VG_CLEAR_COLOR, 4, afClearColour); return true; }
/******************************************************************************* * Function Name : RenderScene * Returns : true if no error occured * Description : Main rendering loop function of the program. The shell will * call this function every frame. *******************************************************************************/ bool CStrokeStyles::RenderScene() { /* If the left or right arrow keys are pressed then change the CapStyle or JoinStyle or DashStyle depending on which one is selected. */ if(PVRShellIsKeyPressed(PVRShellKeyNameLEFT)) { switch(m_i32Selected) { case 0: m_i32CapStyle = (m_i32CapStyle + 2) % 3; break; case 1: m_i32JoinStyle = (m_i32JoinStyle + 2) % 3; break; case 2: m_i32DashStyle = (m_i32DashStyle + 2) % 3; break; } } if(PVRShellIsKeyPressed(PVRShellKeyNameRIGHT)) { switch(m_i32Selected) { case 0: m_i32CapStyle = (m_i32CapStyle + 1) % 3; break; case 1: m_i32JoinStyle = (m_i32JoinStyle + 1) % 3; break; case 2: m_i32DashStyle = (m_i32DashStyle + 1) % 3; break; } } /* If the up or down arrow is pressed then change which item is selected. */ if(PVRShellIsKeyPressed(PVRShellKeyNameUP)) m_i32Selected = (m_i32Selected + 2) % 3; if(PVRShellIsKeyPressed(PVRShellKeyNameDOWN)) m_i32Selected = (m_i32Selected + 1) % 3; vgSeti(VG_MATRIX_MODE, VG_MATRIX_PATH_USER_TO_SURFACE); vgLoadIdentity(); vgScale((float)PVRShellGet(prefWidth), (float)PVRShellGet(prefHeight)); // Clear the screen with clear colour. vgClear(0, 0, PVRShellGet(prefWidth), PVRShellGet(prefHeight)); // Draw the path with the stroke styles that we want vgSeti(VG_STROKE_CAP_STYLE , VG_CAP_BUTT + m_i32CapStyle); vgSeti(VG_STROKE_JOIN_STYLE , VG_JOIN_MITER + m_i32JoinStyle); vgSetf(VG_STROKE_MITER_LIMIT, m_fMiterLimit * PVRShellGet(prefHeight)); if(m_i32DashStyle > 0) { vgSetf(VG_STROKE_DASH_PHASE, m_fDashPhase); static float s_afDashes[] = { 0.1f, 0.15f, 0.23f, 0.11f }; vgSetfv(VG_STROKE_DASH_PATTERN, 4, s_afDashes); if(m_i32DashStyle == 2) m_fDashPhase += 0.01f; } else { vgSetfv(VG_STROKE_DASH_PATTERN, 0, NULL); } vgSetf(VG_STROKE_LINE_WIDTH, 20.0f / PVRShellGet(prefHeight)); vgDrawPath(m_vgPath, VG_STROKE_PATH); /* Draw the text. If one of the pieces of text is currently selected then it will be drawn in yellow. */ static char* apszCapStrings[] = { "Butt", "Round", "Square" }; static char* apszJoinStrings[] = { "Miter", "Round", "Bevel" }; static char* apszDashStrings[] = { "None", "Pattern", "Moving" }; m_PrintVG.DisplayDefaultTitle("StrokeStyles", "", ePVRTPrint3DLogoIMG); float fHeight = PVRShellGet(prefHeight) - 40.0f; /* Draw the Cap text. */ m_PrintVG.DrawString(2.0f , fHeight, 0.6f, "Cap:", (int) PVRTRGBA(204,204,204,255)); m_PrintVG.DrawShadowString(65.0f, fHeight, 0.6f, apszCapStrings[m_i32CapStyle], m_i32Selected == 0 ? (int) PVRTRGBA(255,255,0,255) : (int) PVRTRGBA(255,255,255,255)); /* Draw the Join text. */ fHeight -= 20.0f; m_PrintVG.DrawString(2.0f, fHeight, 0.6f, "Join:", (int) PVRTRGBA(204,204,204,255)); m_PrintVG.DrawShadowString(65.0f, fHeight, 0.6f, apszJoinStrings[m_i32JoinStyle], m_i32Selected == 1 ? (int) PVRTRGBA(255,255,0,255) : (int) PVRTRGBA(255,255,255,255)); /* Draw the Dash text. */ fHeight -= 20.0f; m_PrintVG.DrawString(2.0f,fHeight, 0.6f, "Dash:", (int) PVRTRGBA(204,204,204,255)); m_PrintVG.DrawShadowString(65.0f, fHeight, 0.6f, apszDashStrings[m_i32DashStyle], m_i32Selected == 2 ? (int) PVRTRGBA(255,255,0,255) : (int) PVRTRGBA(255,255,255,255)); return true; }
/*!**************************************************************************** @Function RenderScene @Return bool true if no error occured @Description Main rendering loop function of the program. The shell will call this function every frame. eglSwapBuffers() will be performed by PVRShell automatically. PVRShell will also manage important OS events. Will also manage relevent OS events. The user has access to these events through an abstraction layer provided by PVRShell. ******************************************************************************/ bool OGLES2Refraction::RenderScene() { // Keyboard input (cursor to change Reflection Flag) if (PVRShellIsKeyPressed(PVRShellKeyNameLEFT) || PVRShellIsKeyPressed(PVRShellKeyNameRIGHT)) { m_bSpecular = !m_bSpecular; } // Clear the color and depth buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); m_Background.Draw(m_uiTexture); // Enable backface culling and depth test glCullFace(GL_BACK); glFrontFace(GL_CCW); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); // Use shader program glUseProgram(m_ShaderProgram.uiId); // Bind textures glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_uiTexture); // Calculate the model matrix PVRTMat4 mRotX, mRotY, mModel; mRotX = PVRTMat4::RotationX(m_fAngleX); mRotY = PVRTMat4::RotationY(m_fAngleY); mModel = mRotX * mRotY; m_fAngleX += PVRT_PI / 111; m_fAngleY += PVRT_PI / 150; // Set model view projection matrix PVRTMat4 mModelView, mMVP; mModelView = m_mView * mModel; mMVP = m_mProjection * mModelView; glUniformMatrix4fv(m_ShaderProgram.auiLoc[eMVPMatrix], 1, GL_FALSE, mMVP.ptr()); // Set light direction in model space PVRTVec4 vLightDirModel; vLightDirModel = mModelView.inverse() * PVRTVec4(0.57735f, 0.57735f, 0.57735f, 0); glUniform3fv(m_ShaderProgram.auiLoc[eLightDirModel], 1, &vLightDirModel.x); // Set eye position in model space PVRTVec4 vEyePosModel; vEyePosModel = mModelView.inverse() * PVRTVec4(0, 0, 0, 1); glUniform3fv(m_ShaderProgram.auiLoc[eEyePosModel], 1, &vEyePosModel.x); // Set specular flag glUniform1i(m_ShaderProgram.auiLoc[eSpecular], m_bSpecular); // Set rotation flag glUniform1i(m_ShaderProgram.auiLoc[eRotate], m_bRotate); /* Now that the uniforms are set, call another function to actually draw the mesh. */ DrawMesh(0); // Displays the demo name using the tools. For a detailed explanation, see the training course IntroducingPVRTools m_Print3D.DisplayDefaultTitle("Refraction", "", ePVRTPrint3DLogoIMG); m_Print3D.Print3D(0.3f, 7.5f, 0.75f, PVRTRGBA(255,255,255,255), "Specular reflection: %s", (m_bSpecular) ? "on" : "off" ); m_Print3D.Flush(); return true; }
/*!**************************************************************************** @Function RenderScene @Return bool true if no error occured @Description Main rendering loop function of the program. The shell will call this function every frame. eglSwapBuffers() will be performed by PVRShell automatically. PVRShell will also manage important OS events. Will also manage relevent OS events. The user has access to these events through an abstraction layer provided by PVRShell. ******************************************************************************/ bool OGLESFur::RenderScene() { // Reset the states that print3D changes glDisable(GL_CULL_FACE); glEnable(GL_FOG); glEnable(GL_LIGHT0); glEnable(GL_LIGHTING); glEnable(GL_DEPTH_TEST); // User input bool bNewPage = false; if(PVRShellIsKeyPressed(PVRShellKeyNameSELECT)) m_bPause = !m_bPause; if(PVRShellIsKeyPressed(PVRShellKeyNameLEFT)) { if(--m_i32WndPage < 0) m_i32WndPage = 5; bNewPage = true; } if(PVRShellIsKeyPressed(PVRShellKeyNameRIGHT)) { if(++m_i32WndPage > 5) m_i32WndPage = 0; bNewPage = true; } if(bNewPage) { switch(m_i32WndPage) { case 0: m_bViewMode = false; m_i32FurShellNo = 7; break; case 1: m_bViewMode = true; m_i32FurShellNo = 0; break; case 2: m_bViewMode = true; m_i32FurShellNo = 1; break; case 3: m_bViewMode = true; m_i32FurShellNo = 2; break; case 4: m_bViewMode = true; m_i32FurShellNo = 7; break; case 5: m_bViewMode = false; m_i32FurShellNo = 7; break; } // Since the number of fur shells has changed, update them UpdateFurShells(); } // Clear glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Animation DoAnimation(); // View matrix glMatrixMode(GL_MODELVIEW); glLoadMatrixf(m_mView.f); // Enable the vertex and normal arrays glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); // Begin Scene if(!m_bViewMode) DrawEnvironment(); // Draw the Duck DrawDuck(); // Display Paused if the app is paused if(m_bPause) m_Print3D.Print3D(78.0f, 2.0f, 1.0f, PVRTRGBA(255,255,255,255), "Paused"); // Disable the normals before our drawing of the print3D content glDisableClientState(GL_NORMAL_ARRAY); char szDesc[256]; snprintf(szDesc, 256, "Displaying %d shells", m_i32FurShellNo); // Display the IMG logo m_Print3D.DisplayDefaultTitle("Fur", szDesc, ePVRTPrint3DSDKLogo); m_Print3D.Flush(); return true; }
/******************************************************************************* * Function Name : InitView * Returns : true if no error occured * Description : Code in InitView() will be called by the Shell upon a change * in the rendering context. * Used to initialise variables that are dependent on the rendering * context (e.g. textures, vertex buffers, etc.) *******************************************************************************/ bool CImage::InitView() { //Create a pair of images m_avgImage[0] = vgCreateImage(VG_sRGBA_8888, IMG_SIZE, IMG_SIZE, VG_IMAGE_QUALITY_NONANTIALIASED); m_avgImage[1] = vgCreateImage(VG_sRGBA_8888, IMG_SIZE, IMG_SIZE, VG_IMAGE_QUALITY_NONANTIALIASED); /* The first image will be populated from memory. A 32bit integer array (8bits per component) is created and populated. */ VGuint* pui32ImgData = new VGuint[IMG_SIZE * IMG_SIZE]; for (int i = 0; i < IMG_SIZE; ++i) { for (int j = 0; j < IMG_SIZE; ++j) { // Fills the data with a fancy pattern if ( ((i*j)/8) % 2 ) pui32ImgData[j*IMG_SIZE+i] = PVRTRGBA(255,255,0,255); else pui32ImgData[j*IMG_SIZE+i] = PVRTRGBA(255, 255 - (j * 2), 255 - i, 255 - (i * 2)); } } /* The data in the array is then copied to the portion of the image starting at (0,0) through to (IMG_SIZE, IMG_SIZE), in this case that is the whole image. The coordinate system of the image places (0,0) at the bottom left-hand corner and (IMG_SIZE, IMG_SIZE) at the top right-hand corner. */ vgImageSubData(m_avgImage[0],pui32ImgData, sizeof(VGuint) * IMG_SIZE,VG_sRGBA_8888, 0, 0, IMG_SIZE, IMG_SIZE); // Delete the image data as it is now in OpenVG memory delete[] pui32ImgData; pui32ImgData = 0; /* The second image will initially be cleared to a single colour and then a part of the first image will be copied to it. */ //The colour to clear the image to is taken from the currently set VG_CLEAR_COLOR. VGfloat afClearColour[] = { 1.0f, 0.8f, 0.6f, 1.0f }; vgSetfv(VG_CLEAR_COLOR, 4, afClearColour); //Clear the part of the image in the range (0,0) to (IMG_SIZE, IMG_SIZE), in this case that is the whole image. vgClearImage(m_avgImage[1], 0, 0, IMG_SIZE, IMG_SIZE); /* Copy the bottom left-hand corner ((0,0) to (IMG_SIZE / 2, IMG_SIZE / 2)) of the first image into the the second image starting at (IMG_SIZE / 4, IMG_SIZE / 4). */ int i32ImgSizeQuarter = (int) (IMG_SIZE * 0.25); vgCopyImage(m_avgImage[1], i32ImgSizeQuarter, i32ImgSizeQuarter, m_avgImage[0], 0,0, (VGint) (IMG_SIZE * 0.5), (VGint) (IMG_SIZE * 0.5), (VGboolean) false); //Set the clear colour for clearing the sceen afClearColour[0] = 0.6f; afClearColour[1] = 0.8f; afClearColour[2] = 1.0f; afClearColour[3] = 1.0f; vgSetfv(VG_CLEAR_COLOR, 4, afClearColour); m_PrintVG.Initialize(PVRShellGet(prefWidth), PVRShellGet(prefHeight)); return true; }
/*!*************************************************************************** @Function InitWindow @Input dwBufferSizeX Buffer width @Input dwBufferSizeY Buffer height @Return Window handle @Description Allocate a buffer for a newly-created window and return its handle. *****************************************************************************/ unsigned int CPVRTPrint3D::InitWindow(unsigned int dwBufferSizeX, unsigned int dwBufferSizeY) { #if !defined (DISABLE_PRINT3D) unsigned int dwCurrentWin; /* Find the first available window */ for (dwCurrentWin=1; dwCurrentWin<PVRTPRINT3D_MAX_WINDOWS; dwCurrentWin++) { /* If this window available? */ if (!(m_pWin[dwCurrentWin].dwFlags & Print3D_WIN_EXIST)) { /* Window available, exit loop */ break; } } /* No more windows available? */ if (dwCurrentWin == PVRTPRINT3D_MAX_WINDOWS) { _RPT0(_CRT_WARN,"\nPVRTPrint3DCreateWindow WARNING: PVRTPRINT3D_MAX_WINDOWS overflow.\n"); return 0; } /* Set flags */ m_pWin[dwCurrentWin].dwFlags = Print3D_WIN_TITLE | Print3D_WIN_EXIST | Print3D_WIN_ACTIVE; /* Text Buffer */ m_pWin[dwCurrentWin].dwBufferSizeX = dwBufferSizeX + 1; m_pWin[dwCurrentWin].dwBufferSizeY = dwBufferSizeY; m_pWin[dwCurrentWin].pTextBuffer = (char *)calloc((dwBufferSizeX+2)*(dwBufferSizeY+2), sizeof(char)); m_pWin[dwCurrentWin].bTitleTextL = (char *)calloc(MAX_LETTERS, sizeof(char)); m_pWin[dwCurrentWin].bTitleTextR = (char *)calloc(MAX_LETTERS, sizeof(char)); /* Memory allocation failed */ if (!m_pWin[dwCurrentWin].pTextBuffer || !m_pWin[dwCurrentWin].bTitleTextL || !m_pWin[dwCurrentWin].bTitleTextR) { _RPT0(_CRT_WARN,"\nPVRTPrint3DCreateWindow : No memory enough for Text Buffer.\n"); return 0; } /* Title */ m_pWin[dwCurrentWin].fTitleFontSize = 1.0f; m_pWin[dwCurrentWin].dwTitleFontColorL = PVRTRGBA(0xFF, 0xFF, 0x00, 0xFF); m_pWin[dwCurrentWin].dwTitleFontColorR = PVRTRGBA(0xFF, 0xFF, 0x00, 0xFF); m_pWin[dwCurrentWin].dwTitleBaseColor = PVRTRGBA(0x30, 0x30, 0xFF, 0xFF); /* Dark Blue */ /* Window */ m_pWin[dwCurrentWin].fWinFontSize = 0.5f; m_pWin[dwCurrentWin].dwWinFontColor = PVRTRGBA(0xFF, 0xFF, 0xFF, 0xFF); m_pWin[dwCurrentWin].dwWinBaseColor = PVRTRGBA(0x80, 0x80, 0xFF, 0xFF); /* Light Blue */ m_pWin[dwCurrentWin].fWinPos[0] = 0.0f; m_pWin[dwCurrentWin].fWinPos[1] = 0.0f; m_pWin[dwCurrentWin].fWinSize[0] = 20.0f; m_pWin[dwCurrentWin].fWinSize[1] = 20.0f; m_pWin[dwCurrentWin].fZPos = 0.0f; m_pWin[dwCurrentWin].dwSort = 0; m_pWin[dwCurrentWin].bNeedUpdated = true; dwCurrentWin++; /* Returning the handle */ return (dwCurrentWin-1); #else return 0; #endif }