void GenericBuffer::CopyFrom(vk::CommandBuffer commandBuffer, Texture& srcTexture) { auto textureSize = srcTexture.GetWidth() * srcTexture.GetHeight() * GetBytesPerPixel(srcTexture.GetFormat()); if (textureSize != mSize) { throw std::runtime_error("Cannot copy texture of different sizes"); } srcTexture.Barrier(commandBuffer, vk::ImageLayout::eGeneral, vk::AccessFlagBits::eShaderWrite | vk::AccessFlagBits::eColorAttachmentWrite, vk::ImageLayout::eTransferSrcOptimal, vk::AccessFlagBits::eTransferRead); auto info = vk::BufferImageCopy() .setImageSubresource({vk::ImageAspectFlagBits::eColor, 0, 0, 1}) .setImageExtent({srcTexture.GetWidth(), srcTexture.GetHeight(), 1}); commandBuffer.copyImageToBuffer( srcTexture.mImage, vk::ImageLayout::eTransferSrcOptimal, mBuffer, info); srcTexture.Barrier(commandBuffer, vk::ImageLayout::eTransferSrcOptimal, vk::AccessFlagBits::eTransferRead, vk::ImageLayout::eGeneral, vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eColorAttachmentRead); Barrier(commandBuffer, vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead); }
void GSDevice10::StretchRect(Texture& st, const GSVector4& sr, Texture& dt, const GSVector4& dr, ID3D10PixelShader* ps, ID3D10Buffer* ps_cb, ID3D10BlendState* bs, bool linear) { BeginScene(); // om OMSetDepthStencilState(m_convert.dss, 0); OMSetBlendState(bs, 0); OMSetRenderTargets(dt, NULL); // ia float left = dr.x * 2 / dt.GetWidth() - 1.0f; float top = 1.0f - dr.y * 2 / dt.GetHeight(); float right = dr.z * 2 / dt.GetWidth() - 1.0f; float bottom = 1.0f - dr.w * 2 / dt.GetHeight(); GSVertexPT1 vertices[] = { {GSVector4(left, top, 0.5f, 1.0f), GSVector2(sr.x, sr.y)}, {GSVector4(right, top, 0.5f, 1.0f), GSVector2(sr.z, sr.y)}, {GSVector4(left, bottom, 0.5f, 1.0f), GSVector2(sr.x, sr.w)}, {GSVector4(right, bottom, 0.5f, 1.0f), GSVector2(sr.z, sr.w)}, }; D3D10_BOX box = {0, 0, 0, sizeof(vertices), 1, 1}; m_dev->UpdateSubresource(m_convert.vb, 0, &box, vertices, 0, 0); IASetVertexBuffer(m_convert.vb, sizeof(vertices[0])); IASetInputLayout(m_convert.il); IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); // vs VSSetShader(m_convert.vs, NULL); // gs GSSetShader(NULL); // ps PSSetShader(ps, ps_cb); PSSetSamplerState(linear ? m_convert.ln : m_convert.pt, NULL); PSSetShaderResources(st, NULL); // rs RSSet(dt.GetWidth(), dt.GetHeight()); // DrawPrimitive(countof(vertices)); // EndScene(); }
void GSDevice10::DoInterlace(Texture& st, Texture& dt, int shader, bool linear, float yoffset) { GSVector4 sr(0, 0, 1, 1); GSVector4 dr(0.0f, yoffset, (float)dt.GetWidth(), (float)dt.GetHeight() + yoffset); InterlaceConstantBuffer cb; cb.ZrH = GSVector2(0, 1.0f / dt.GetHeight()); cb.hH = (float)dt.GetHeight() / 2; m_dev->UpdateSubresource(m_interlace.cb, 0, NULL, &cb, 0, 0); StretchRect(st, sr, dt, dr, m_interlace.ps[shader], m_interlace.cb, linear); }
void Sprite::SetTexture(const Texture& texture, bool adjustToNewSize) { // If there was no valid texture before, force adjusting to the new texture size if (!myTexture) adjustToNewSize = true; // If we want to adjust the size and the new texture is valid, we adjust the source rectangle if (adjustToNewSize && (texture.GetWidth() > 0) && (texture.GetHeight() > 0)) { SetSubRect(IntRect(0, 0, texture.GetWidth(), texture.GetHeight())); } // Assign the new texture myTexture = &texture; }
void Terrain::Load() { std::cout << "Loading Terrain" << std::endl; Texture* heightmap = new Texture(); heightmap->SetFile(sFilepath); heightmap->Load(); iWidth = heightmap->GetWidth(); iLength = heightmap->GetHeight(); pHeights = new float*[iLength]; for(int i = 0; i < iLength; i++) { pHeights[i] = new float[iWidth]; } vNormals = new glm::vec3*[iLength]; for(int i = 0; i < iLength; i++) { vNormals[i] = new glm::vec3[iWidth]; } for(int y = 0; y < iLength; y++) { for(int x = 0; x < iWidth; x++) { unsigned char color = heightmap->GetData()[3 * (y * iWidth + x)]; float h = fScale * ((color / 255.0f) - 0.5f); SetHeight(x, y, h); } } delete heightmap; ComputeNormals(); }
void ESSUB_LoadPNG (const std::string& aPath, Texture** aTexture) { assert(aTexture); wchar_t buffer[1024]; MultiByteToWideChar(CP_UTF8, 0, aPath.c_str(), -1, buffer, 512); Texture* output = 0; Bitmap img(buffer, false); if(img.GetWidth()) { output = ESVideo::CreateTexture(img.GetWidth(), img.GetHeight(), true); output->Clear(0); BitmapData BMData; BMData.Width = std::min(output->GetWidth(), img.GetWidth()); BMData.Height = std::min(output->GetHeight(), img.GetHeight()); BMData.Stride = output->GetWidth() * 4; BMData.PixelFormat = PixelFormat32bppARGB; BMData.Scan0 = output->Map(); BMData.Reserved = 0; Rect area(0, 0, img.GetWidth(), img.GetHeight()); img.LockBits(&area, ImageLockModeRead | ImageLockModeUserInputBuf, PixelFormat32bppARGB, &BMData); img.UnlockBits(&BMData); output->Unmap(); } *aTexture = output; }
void LandscapeEditorCustomColors::RestoreState(DAVA::Image *image) { Texture* texture = Texture::CreateTextFromData(image->GetPixelFormat(), image->GetData(), image->GetWidth(), image->GetHeight(), false); Sprite* sprite = Sprite::CreateFromTexture(texture, 0, 0, texture->GetWidth(), texture->GetHeight()); uint32 width = 0; uint32 height = 0; if (colorSprite) { width = colorSprite->GetWidth(); height = colorSprite->GetHeight(); } else { width = texSurf->GetWidth(); height = texSurf->GetHeight(); } SafeRelease(colorSprite); colorSprite = Sprite::CreateAsRenderTarget(width, height, FORMAT_RGBA8888); RenderManager::Instance()->SetRenderTarget(colorSprite); sprite->Draw(); RenderManager::Instance()->RestoreRenderTarget(); SafeRelease(sprite); SafeRelease(texture); if (IsActive()) PerformLandscapeDraw(); unsavedChanges = true; }
Texture* GetTexture () { Texture* output = 0; if(Valid) { output = ESVideo::CreateTexture(Width, Height, true); output->Clear(0); uint32_t copyWidth = std::min(Width, output->GetWidth()); uint32_t copyHeight = std::min(Height, output->GetHeight()); uint32_t* texPixels = output->Map(); for(int i = 0; i != copyHeight; i ++) { uint32_t* dest = texPixels + (output->GetPitch() * i); uint8_t* source = RowPointers[i]; for(int j = 0; j != copyWidth; j ++) { uint32_t a = (InfoPtr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) ? *source++ : 0xFF; uint32_t r = *source ++; uint32_t g = *source ++; uint32_t b = *source ++; *dest++ = output->ConvertPixel(r, g, b, a); } } output->Unmap(); } return output; }
bool CustomColorsSystem::LoadTexture( const DAVA::FilePath &filePath, bool createUndo /* = true */ ) { if(filePath.IsEmpty()) return false; Vector<Image*> images; ImageSystem::Instance()->Load(filePath, images); if(images.empty()) return false; Image* image = images.front(); if(image) { Texture* texture = Texture::CreateFromData(image->GetPixelFormat(), image->GetData(), image->GetWidth(), image->GetHeight(), false); Sprite* sprite = Sprite::CreateFromTexture(texture, 0, 0, texture->GetWidth(), texture->GetHeight()); if (createUndo) { StoreOriginalState(); } RenderManager::Instance()->SetRenderTarget(drawSystem->GetCustomColorsProxy()->GetSprite()); Sprite::DrawState drawState; sprite->Draw(&drawState); RenderManager::Instance()->RestoreRenderTarget(); AddRectToAccumulator(Rect(Vector2(0.f, 0.f), Vector2(texture->GetWidth(), texture->GetHeight()))); SafeRelease(sprite); SafeRelease(texture); for_each(images.begin(), images.end(), SafeRelease<Image>); if (createUndo) { ((SceneEditor2*)GetScene())->BeginBatch("Load custom colors texture"); StoreSaveFileName(filePath); CreateUndoPoint(); ((SceneEditor2*)GetScene())->EndBatch(); } } return true; }
void Graphics::DrawTexture(const Rect& screenCoords, int textureId, float xOffset, float yOffset) { Texture* texture = ResourceManager::GetInstance().GetTexture(textureId); if (!texture) return; Rect textureCoords; textureCoords.left = 0.0f; textureCoords.top = 0.0f; textureCoords.right = texture->GetWidth(); textureCoords.bottom = texture->GetHeight(); DrawTexture(screenCoords, textureId, textureCoords, xOffset, yOffset); }
void SpriteBatch::Draw(int tex_id, RectInt* rect, VecInt* pos, unsigned char alpha/* = 0xff*/, float scl /* = 1.0f */, float rot /* = 0.0f */) { if (sm_state != BEGAN) return; Texture* tex = TextureManager::GetTexture(tex_id); if (tex == NULL) return; RECT tex_rect; RECT* ptex_rect = &tex_rect; if (rect) SetRect(ptex_rect, rect->left, rect->top, rect->left + rect->width, rect->top + rect->height); else SetRect(ptex_rect, 0, 0, tex->GetWidth(), tex->GetHeight()); D3DXVECTOR3 v3pos; v3pos.x = (pos == NULL) ? 0.0f : (float)(pos->x); v3pos.y = (pos == NULL) ? 0.0f : (float)(pos->y); v3pos.z = 0.0f; DWORD color = alpha << 24; color += 0x00ffffff; g_pSprite->Draw(tex->GetD3DTexture(), ptex_rect, NULL, &v3pos, color); }
// the operator ComTexture Texture::operator * ( const Texture& tex ) const { if( tex.GetWidth() != m_iTexWidth || tex.GetHeight() != m_iTexHeight ) LOG_ERROR<<"Size of the images are not the same , can't multiply."<<CRASH; if( m_iTexWidth == 0 || m_iTexHeight == 0 ) LOG_ERROR<<"One dimension of the image is zero , can't multiply."<<CRASH; //allocate the data Spectrum* data = new Spectrum[ m_iTexWidth * m_iTexHeight ]; for( unsigned i = 0 ; i < m_iTexHeight; i++ ) for( unsigned j = 0 ; j < m_iTexWidth ; j++ ) { unsigned offset = i * m_iTexWidth + j; data[offset] = tex.GetColor( (int)j , (int)i ) * GetColor( (int)j , (int)i ); } return ComTexture( data , m_iTexWidth , m_iTexHeight ); }
void LandscapeEditorCustomColors::LoadTextureAction(const FilePath &pathToFile) { if(pathToFile.IsEmpty()) return; Vector<Image*> images = ImageLoader::CreateFromFile(pathToFile); if(images.empty()) return; Image* image = images.front(); if(image) { Texture* texture = Texture::CreateFromData(image->GetPixelFormat(), image->GetData(), image->GetWidth(), image->GetHeight(), false); SafeRelease(colorSprite); colorSprite = Sprite::CreateAsRenderTarget(texSurf->GetWidth(), texSurf->GetHeight(), FORMAT_RGBA8888); Sprite* sprite = Sprite::CreateFromTexture(texture, 0, 0, texture->GetWidth(), texture->GetHeight()); StoreOriginalState(); RenderManager::Instance()->SetRenderTarget(colorSprite); sprite->Draw(); RenderManager::Instance()->RestoreRenderTarget(); PerformLandscapeDraw(); SafeRelease(sprite); SafeRelease(texture); for_each(images.begin(), images.end(), SafeRelease<Image>); StoreSaveFileName(pathToFile); CreateUndoPoint(); } }
Sprite* ModifyTilemaskCommand::ApplyImageToTexture(DAVA::Image *image, DAVA::Texture *texture) { int32 width = texture->GetWidth(); int32 height = texture->GetHeight(); Sprite* resSprite = Sprite::CreateAsRenderTarget((float32)width, (float32)height, FORMAT_RGBA8888); RenderManager::Instance()->SetRenderTarget(resSprite); RenderManager::Instance()->ClearWithColor(0.f, 0.f, 0.f, 0.f); eBlendMode srcBlend = RenderManager::Instance()->GetSrcBlend(); eBlendMode dstBlend = RenderManager::Instance()->GetDestBlend(); RenderManager::Instance()->SetBlendMode(BLEND_ONE, BLEND_ZERO); Sprite* s = Sprite::CreateFromTexture(texture, 0, 0, (float32)width, (float32)height); s->SetPosition(0.f, 0.f); s->Draw(); SafeRelease(s); RenderManager::Instance()->ClipPush(); RenderManager::Instance()->SetClip(updatedRect); RenderManager::Instance()->ClearWithColor(0.f, 0.f, 0.f, 0.f); Texture* t = Texture::CreateFromData(image->GetPixelFormat(), image->GetData(), image->GetWidth(), image->GetHeight(), false); s = Sprite::CreateFromTexture(t, 0, 0, (float32)t->GetWidth(), (float32)t->GetHeight()); s->SetPosition(updatedRect.x, updatedRect.y); s->Draw(); SafeRelease(s); SafeRelease(t); RenderManager::Instance()->ClipPop(); RenderManager::Instance()->SetBlendMode(srcBlend, dstBlend); RenderManager::Instance()->ResetColor(); RenderManager::Instance()->RestoreRenderTarget(); return resSprite; }
void gfx::GraphicsEngine::RenderActiveTarget(){ glViewport((GLint)(m_Width * 0.5f), BUTTON_SIZE, (GLint)(m_Width * 0.5f), m_Height - BUTTON_SIZE * 2); glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); ShaderProgram* spriteProg = g_ShaderBank.GetProgramFromHandle(m_SpriteShader); spriteProg->Apply(); glBindVertexArray(0); Texture* tex = g_MaterialBank.GetTexture(m_FrameBuffer.GetTexture()); float sizeH; sizeH = tex->GetHeight() / tex->GetWidth(); tex->Apply(spriteProg->FetchUniform("g_Texture"), 0); spriteProg->SetUniformVec4("g_Color", glm::vec4(1)); spriteProg->SetUniformVec4("g_Pos", glm::vec4(0.0f, 0.5f + sizeH * 0.5f, 0.0f,0.0f)); spriteProg->SetUniformVec4("g_Size", glm::vec4(1.0f, sizeH, 1.0f, 1.0f)); if (tex->GetChannels() == 1){ spriteProg->SetUniformBool("g_GreyScale", true); } else{ spriteProg->SetUniformBool("g_GreyScale", false); } glDrawArrays(GL_POINTS, 0, 1); }
void CommandModifyCustomColors::ApplyImage(DAVA::Image *image) { Sprite* customColorsSprite = customColorsProxy->GetSprite(); Texture* texture = Texture::CreateFromData(image->GetPixelFormat(), image->GetData(), image->GetWidth(), image->GetHeight(), false); Sprite* sprite = Sprite::CreateFromTexture(texture, 0, 0, texture->GetWidth(), texture->GetHeight()); RenderManager::Instance()->SetRenderTarget(customColorsSprite); RenderManager::Instance()->ClipPush(); RenderManager::Instance()->ClipRect(updatedRect); RenderManager::Instance()->ClearWithColor(0.f, 0.f, 0.f, 0.f); sprite->SetPosition(updatedRect.x, updatedRect.y); sprite->Draw(); RenderManager::Instance()->ClipPop(); RenderManager::Instance()->RestoreRenderTarget(); customColorsProxy->UpdateRect(updatedRect); SafeRelease(sprite); SafeRelease(texture); }
void UIControlBackground::DrawStretched(const Rect &drawRect) { if (!spr)return; Texture *texture = spr->GetTexture(frame); float32 texX = spr->GetRectOffsetValueForFrame(frame, Sprite::X_POSITION_IN_TEXTURE); float32 texY = spr->GetRectOffsetValueForFrame(frame, Sprite::Y_POSITION_IN_TEXTURE); float32 texDx = spr->GetRectOffsetValueForFrame(frame, Sprite::ACTIVE_WIDTH); float32 texDy = spr->GetRectOffsetValueForFrame(frame, Sprite::ACTIVE_HEIGHT); float32 texOffX = spr->GetRectOffsetValueForFrame(frame, Sprite::X_OFFSET_TO_ACTIVE); float32 texOffY = spr->GetRectOffsetValueForFrame(frame, Sprite::Y_OFFSET_TO_ACTIVE); const float32 spriteWidth = spr->GetWidth(); const float32 spriteHeight = spr->GetHeight(); const float32 leftOffset = leftStretchCap - texOffX; const float32 rightOffset = leftStretchCap - ( spriteWidth - texDx - texOffX ); const float32 topOffset = topStretchCap - texOffY; const float32 bottomOffset= topStretchCap - ( spriteHeight - texDy - texOffY ); const float32 realLeftStretchCap = Max( 0.0f, leftOffset ); const float32 realRightStretchCap = Max( 0.0f, rightOffset ); const float32 realTopStretchCap = Max( 0.0f, topOffset ); const float32 realBottomStretchCap= Max( 0.0f, bottomOffset ); const float32 scaleFactorX = drawRect.dx / spriteWidth; const float32 scaleFactorY = drawRect.dy / spriteHeight; const float32 x = drawRect.x + Max( 0.0f, -leftOffset ) * scaleFactorX; const float32 y = drawRect.y + Max( 0.0f, -topOffset ) * scaleFactorY; const float32 dx = drawRect.dx - ( Max( 0.0f, -leftOffset ) + Max( 0.0f, -rightOffset ) ) * scaleFactorX; const float32 dy = drawRect.dy - ( Max( 0.0f, -topOffset ) + Max( 0.0f, -bottomOffset ) ) * scaleFactorY; const float32 resMulFactor = 1.0f / Core::Instance()->GetResourceToVirtualFactor(spr->GetResourceSizeIndex()); // if (spr->IsUseContentScale()) // { texDx *= resMulFactor; texDy *= resMulFactor; // } const float32 leftCap = realLeftStretchCap * resMulFactor; const float32 rightCap = realRightStretchCap * resMulFactor; const float32 topCap = realTopStretchCap * resMulFactor; const float32 bottomCap= realBottomStretchCap * resMulFactor; float32 vertices[16 * 2]; float32 texCoords[16 * 2]; float32 textureWidth = (float32)texture->GetWidth(); float32 textureHeight = (float32)texture->GetHeight(); int32 vertInTriCount = 18; int32 vertCount = 16; switch (type) { case DRAW_STRETCH_HORIZONTAL: { vertices[0] = vertices[8] = x; vertices[1] = vertices[3] = vertices[5] = vertices[7] = y; vertices[4] = vertices[12] = x + dx - realRightStretchCap; vertices[2] = vertices[10] = x + realLeftStretchCap; vertices[9] = vertices[11] = vertices[13] = vertices[15] = y + dy; vertices[6] = vertices[14] = x + dx; texCoords[0] = texCoords[8] = texX / textureWidth; texCoords[1] = texCoords[3] = texCoords[5] = texCoords[7] = texY / textureHeight; texCoords[4] = texCoords[12] = (texX + texDx - rightCap) / textureWidth; texCoords[2] = texCoords[10] = (texX + leftCap) / textureWidth; texCoords[9] = texCoords[11] = texCoords[13] = texCoords[15] = (texY + texDy) / textureHeight; texCoords[6] = texCoords[14] = (texX + texDx) / textureWidth; } break; case DRAW_STRETCH_VERTICAL: { vertices[0] = vertices[2] = vertices[4] = vertices[6] = x; vertices[8] = vertices[10] = vertices[12] = vertices[14] = x + dx; vertices[1] = vertices[9] = y; vertices[3] = vertices[11] = y + realTopStretchCap; vertices[5] = vertices[13] = y + dy - realBottomStretchCap; vertices[7] = vertices[15] = y + dy; texCoords[0] = texCoords[2] = texCoords[4] = texCoords[6] = texX / textureWidth; texCoords[8] = texCoords[10] = texCoords[12] = texCoords[14] = (texX + texDx) / textureWidth; texCoords[1] = texCoords[9] = texY / textureHeight; texCoords[3] = texCoords[11] = (texY + topCap) / textureHeight; texCoords[5] = texCoords[13] = (texY + texDy - bottomCap) / textureHeight; texCoords[7] = texCoords[15] = (texY + texDy) / textureHeight; } break; case DRAW_STRETCH_BOTH: { vertInTriCount = 18 * 3; vertCount = 32; vertices[0] = vertices[8] = vertices[16] = vertices[24] = x; vertices[2] = vertices[10] = vertices[18] = vertices[26] = x + realLeftStretchCap; vertices[4] = vertices[12] = vertices[20] = vertices[28] = x + dx - realRightStretchCap; vertices[6] = vertices[14] = vertices[22] = vertices[30] = x + dx; vertices[1] = vertices[3] = vertices[5] = vertices[7] = y; vertices[9] = vertices[11] = vertices[13] = vertices[15] = y + realTopStretchCap; vertices[17]= vertices[19] = vertices[21] = vertices[23] = y + dy - realBottomStretchCap; vertices[25]= vertices[27] = vertices[29] = vertices[31] = y + dy; texCoords[0] = texCoords[8] = texCoords[16] = texCoords[24] = texX / textureWidth; texCoords[2] = texCoords[10] = texCoords[18] = texCoords[26] = (texX + leftCap) / textureWidth; texCoords[4] = texCoords[12] = texCoords[20] = texCoords[28] = (texX + texDx - rightCap) / textureWidth; texCoords[6] = texCoords[14] = texCoords[22] = texCoords[30] = (texX + texDx) / textureWidth; texCoords[1] = texCoords[3] = texCoords[5] = texCoords[7] = texY / textureHeight; texCoords[9] = texCoords[11] = texCoords[13] = texCoords[15] = (texY + topCap) / textureHeight; texCoords[17] = texCoords[19] = texCoords[21] = texCoords[23] = (texY + texDy - bottomCap) / textureHeight; texCoords[25] = texCoords[27] = texCoords[29] = texCoords[31] = (texY + texDy) / textureHeight; } break; } // if (Core::GetContentScaleFactor() != 1.0 && RenderManager::IsRenderTarget()) // { // for (int i = 0; i < vertCount; i++) // { // vertices[i] *= Core::GetVirtualToPhysicalFactor(); // } // } uint16 indeces[18 * 3] = { 0, 1, 4, 1, 5, 4, 1, 2, 5, 2, 6, 5, 2, 3, 6, 3, 7, 6, 4, 5, 8, 5, 9, 8, 5, 6, 9, 6, 10, 9, 6, 7, 10, 7, 11, 10, 8, 9, 12, 9, 12, 13, 9, 10, 13, 10, 14, 13, 10, 11, 14, 11, 15, 14 }; vertexStream->Set(TYPE_FLOAT, 2, 0, vertices); texCoordStream->Set(TYPE_FLOAT, 2, 0, texCoords); RenderManager::Instance()->SetTexture(texture); RenderManager::Instance()->SetRenderEffect(RenderManager::TEXTURE_MUL_FLAT_COLOR); RenderManager::Instance()->SetRenderData(rdoObject); RenderManager::Instance()->DrawElements(PRIMITIVETYPE_TRIANGLELIST, vertInTriCount, EIF_16, indeces); /*GLenum glErr = glGetError(); if (glErr != GL_NO_ERROR) { Logger::Debug("GLError: 0x%x", glErr); }*/ }
Image* HeightmapEditorSystem::CreateToolImage(int32 sideSize, const FilePath& filePath) { Sprite *dstSprite = Sprite::CreateAsRenderTarget((float32)sideSize, (float32)sideSize, FORMAT_RGBA8888); Texture *srcTex = Texture::CreateFromFile(filePath); Sprite *srcSprite = Sprite::CreateFromTexture(srcTex, 0, 0, (float32)srcTex->GetWidth(), (float32)srcTex->GetHeight()); RenderManager::Instance()->SetRenderTarget(dstSprite); RenderManager::Instance()->ClearWithColor(0.f, 0.f, 0.f, 0.f); RenderManager::Instance()->SetBlendMode(BLEND_SRC_ALPHA, BLEND_ONE_MINUS_SRC_ALPHA); RenderManager::Instance()->SetColor(Color::White()); srcSprite->SetScaleSize((float32)sideSize, (float32)sideSize); srcSprite->SetPosition(Vector2((dstSprite->GetTexture()->GetWidth() - sideSize)/2.0f, (dstSprite->GetTexture()->GetHeight() - sideSize)/2.0f)); srcSprite->Draw(); RenderManager::Instance()->RestoreRenderTarget(); Image *retImage = dstSprite->GetTexture()->CreateImageFromMemory(); SafeRelease(srcSprite); SafeRelease(srcTex); SafeRelease(dstSprite); return retImage; }
void UIControlBackground::DrawStretched(const Rect &drawRect) { if (!spr)return; Texture *texture = spr->GetTexture(frame); float32 x = spr->GetRectOffsetValueForFrame(frame, Sprite::X_POSITION_IN_TEXTURE); float32 y = spr->GetRectOffsetValueForFrame(frame, Sprite::Y_POSITION_IN_TEXTURE); float32 dx = spr->GetRectOffsetValueForFrame(frame, Sprite::ACTIVE_WIDTH); float32 dy = spr->GetRectOffsetValueForFrame(frame, Sprite::ACTIVE_HEIGHT); // if (spr->IsUseContentScale()) // { dx /= Core::Instance()->GetResourceToVirtualFactor(spr->GetResourceSizeIndex()); dy /= Core::Instance()->GetResourceToVirtualFactor(spr->GetResourceSizeIndex()); // } float32 leftCap = leftStretchCap / Core::Instance()->GetResourceToVirtualFactor(spr->GetResourceSizeIndex()); float32 topCap = topStretchCap / Core::Instance()->GetResourceToVirtualFactor(spr->GetResourceSizeIndex()); float32 vertices[16 * 2]; float32 texCoords[16 * 2]; float32 textureWidth = (float32)texture->GetWidth(); float32 textureHeight = (float32)texture->GetHeight(); int32 vertInTriCount = 18; int32 vertCount = 16; switch (type) { case DRAW_STRETCH_HORIZONTAL: { vertices[0] = drawRect.x; vertices[1] = drawRect.y; vertices[2] = drawRect.x + leftStretchCap; vertices[3] = drawRect.y; vertices[4] = drawRect.x + drawRect.dx - leftStretchCap; vertices[5] = drawRect.y; vertices[6] = drawRect.x + drawRect.dx; vertices[7] = drawRect.y; vertices[8] = drawRect.x; vertices[9] = drawRect.y + drawRect.dy; vertices[10] = drawRect.x + leftStretchCap; vertices[11] = drawRect.y + drawRect.dy; vertices[12] = drawRect.x + drawRect.dx - leftStretchCap; vertices[13] = drawRect.y + drawRect.dy; vertices[14] = drawRect.x + drawRect.dx; vertices[15] = drawRect.y + drawRect.dy; texCoords[0] = x / textureWidth; texCoords[1] = y / textureHeight; texCoords[2] = (x + leftCap) / textureWidth; texCoords[3] = y / textureHeight; texCoords[4] = (x + dx - leftCap) / textureWidth; texCoords[5] = y / textureHeight; texCoords[6] = (x + dx) / textureWidth; texCoords[7] = y / textureHeight; texCoords[8] = x / textureWidth; texCoords[9] = (y + dy) / textureHeight; texCoords[10] = (x + leftCap) / textureWidth; texCoords[11] = (y + dy) / textureHeight; texCoords[12] = (x + dx - leftCap) / textureWidth; texCoords[13] = (y + dy) / textureHeight; texCoords[14] = (x + dx) / textureWidth; texCoords[15] = (y + dy) / textureHeight; } break; case DRAW_STRETCH_VERTICAL: { vertices[0] = drawRect.x; vertices[1] = drawRect.y; vertices[2] = drawRect.x; vertices[3] = drawRect.y + topStretchCap; vertices[4] = drawRect.x; vertices[5] = drawRect.y + drawRect.dy - topStretchCap; vertices[6] = drawRect.x; vertices[7] = drawRect.y + drawRect.dy; vertices[8] = drawRect.x + drawRect.dx; vertices[9] = drawRect.y; vertices[10] = drawRect.x + drawRect.dx; vertices[11] = drawRect.y + topStretchCap; vertices[12] = drawRect.x + drawRect.dx; vertices[13] = drawRect.y + drawRect.dy - topStretchCap; vertices[14] = drawRect.x + drawRect.dx; vertices[15] = drawRect.y + drawRect.dy; texCoords[0] = x / textureWidth; texCoords[1] = y / textureHeight; texCoords[2] = x / textureWidth; texCoords[3] = (y + topCap) / textureHeight; texCoords[4] = x / textureWidth; texCoords[5] = (y + dy - topCap) / textureHeight; texCoords[6] = x / textureWidth; texCoords[7] = (y + dy) / textureHeight; texCoords[8] = (x + dx) / textureWidth; texCoords[9] = y / textureHeight; texCoords[10] = (x + dx) / textureWidth; texCoords[11] = (y + topCap) / textureHeight; texCoords[12] = (x + dx) / textureWidth; texCoords[13] = (y + dy - topCap) / textureHeight; texCoords[14] = (x + dx) / textureWidth; texCoords[15] = (y + dy) / textureHeight; } break; case DRAW_STRETCH_BOTH: { vertInTriCount = 18 * 3; vertCount = 32; vertices[0] = drawRect.x; vertices[1] = drawRect.y; vertices[2] = drawRect.x + leftStretchCap; vertices[3] = drawRect.y; vertices[4] = drawRect.x + drawRect.dx - leftStretchCap; vertices[5] = drawRect.y; vertices[6] = drawRect.x + drawRect.dx; vertices[7] = drawRect.y; vertices[8] = drawRect.x; vertices[9] = drawRect.y + topStretchCap; vertices[10] = drawRect.x + leftStretchCap; vertices[11] = drawRect.y + topStretchCap; vertices[12] = drawRect.x + drawRect.dx - leftStretchCap; vertices[13] = drawRect.y + topStretchCap; vertices[14] = drawRect.x + drawRect.dx; vertices[15] = drawRect.y + topStretchCap; vertices[16] = drawRect.x; vertices[17] = drawRect.y + drawRect.dy - topStretchCap; vertices[18] = drawRect.x + leftStretchCap; vertices[19] = drawRect.y + drawRect.dy - topStretchCap; vertices[20] = drawRect.x + drawRect.dx - leftStretchCap; vertices[21] = drawRect.y + drawRect.dy - topStretchCap; vertices[22] = drawRect.x + drawRect.dx; vertices[23] = drawRect.y + drawRect.dy - topStretchCap; vertices[24] = drawRect.x; vertices[25] = drawRect.y + drawRect.dy; vertices[26] = drawRect.x + leftStretchCap; vertices[27] = drawRect.y + drawRect.dy; vertices[28] = drawRect.x + drawRect.dx - leftStretchCap; vertices[29] = drawRect.y + drawRect.dy; vertices[30] = drawRect.x + drawRect.dx; vertices[31] = drawRect.y + drawRect.dy; // texCoords[0] = x / textureWidth; texCoords[1] = y / textureHeight; texCoords[2] = (x + leftCap) / textureWidth; texCoords[3] = y / textureHeight; texCoords[4] = (x + dx - leftCap) / textureWidth; texCoords[5] = y / textureHeight; texCoords[6] = (x + dx) / textureWidth; texCoords[7] = y / textureHeight; texCoords[8] = x / textureWidth; texCoords[9] = (y + topCap) / textureHeight; texCoords[10] = (x + leftCap) / textureWidth; texCoords[11] = (y + topCap) / textureHeight; texCoords[12] = (x + dx - leftCap) / textureWidth; texCoords[13] = (y + topCap) / textureHeight; texCoords[14] = (x + dx) / textureWidth; texCoords[15] = (y + topCap) / textureHeight; texCoords[16] = x / textureWidth; texCoords[17] = (y + dy - topCap) / textureHeight; texCoords[18] = (x + leftCap) / textureWidth; texCoords[19] = (y + dy - topCap) / textureHeight; texCoords[20] = (x + dx - leftCap) / textureWidth; texCoords[21] = (y + dy - topCap) / textureHeight; texCoords[22] = (x + dx) / textureWidth; texCoords[23] = (y + dy - topCap) / textureHeight; texCoords[24] = x / textureWidth; texCoords[25] = (y + dy) / textureHeight; texCoords[26] = (x + leftCap) / textureWidth; texCoords[27] = (y + dy) / textureHeight; texCoords[28] = (x + dx - leftCap) / textureWidth; texCoords[29] = (y + dy) / textureHeight; texCoords[30] = (x + dx) / textureWidth; texCoords[31] = (y + dy) / textureHeight; } break; } // if (Core::GetContentScaleFactor() != 1.0 && RenderManager::IsRenderTarget()) // { // for (int i = 0; i < vertCount; i++) // { // vertices[i] *= Core::GetVirtualToPhysicalFactor(); // } // } uint16 indeces[18 * 3] = { 0, 1, 4, 1, 5, 4, 1, 2, 5, 2, 6, 5, 2, 3, 6, 3, 7, 6, 4, 5, 8, 5, 9, 8, 5, 6, 9, 6, 10, 9, 6, 7, 10, 7, 11, 10, 8, 9, 12, 9, 12, 13, 9, 10, 13, 10, 14, 13, 10, 11, 14, 11, 15, 14 }; vertexStream->Set(TYPE_FLOAT, 2, 0, vertices); texCoordStream->Set(TYPE_FLOAT, 2, 0, texCoords); RenderManager::Instance()->SetTexture(texture); RenderManager::Instance()->SetRenderEffect(RenderManager::TEXTURE_MUL_FLAT_COLOR); RenderManager::Instance()->SetRenderData(rdoObject); RenderManager::Instance()->DrawElements(PRIMITIVETYPE_TRIANGLELIST, vertInTriCount, EIF_16, indeces); /*GLenum glErr = glGetError(); if (glErr != GL_NO_ERROR) { Logger::Debug("GLError: 0x%x", glErr); }*/ }
void Text3D::UpdateTextMaterials(bool forceUpdate) { batches_.Resize(uiBatches_.Size()); geometries_.Resize(uiBatches_.Size()); for (unsigned i = 0; i < batches_.Size(); ++i) { if (!geometries_[i]) { Geometry* geometry = new Geometry(context_); geometry->SetVertexBuffer(0, vertexBuffer_, MASK_POSITION | MASK_COLOR | MASK_TEXCOORD1); batches_[i].geometry_ = geometries_[i] = geometry; } if (!batches_[i].material_ || forceUpdate) { // If material not defined, create a reasonable default from scratch if (!material_) { Material* material = new Material(context_); Technique* tech = new Technique(context_); Pass* pass = tech->CreatePass(PASS_ALPHA); pass->SetVertexShader("Text"); pass->SetPixelShader("Text"); if (GetFont()->IsSDFFont()) { switch (GetTextEffect()) { case TE_NONE: pass->SetPixelShaderDefines("SIGNED_DISTANCE_FIELD"); break; case TE_SHADOW: pass->SetPixelShaderDefines("SIGNED_DISTANCE_FIELD TEXT_EFFECT_SHADOW"); break; case TE_STROKE: pass->SetPixelShaderDefines("SIGNED_DISTANCE_FIELD TEXT_EFFECT_STROKE"); break; } } pass->SetBlendMode(BLEND_ALPHA); pass->SetDepthWrite(false); material->SetTechnique(0, tech); material->SetCullMode(CULL_NONE); batches_[i].material_ = material; } else batches_[i].material_ = material_->Clone(); } Material* material = batches_[i].material_; Texture* texture = uiBatches_[i].texture_; material->SetTexture(TU_DIFFUSE, texture); if (GetFont()->IsSDFFont()) { switch (GetTextEffect()) { case TE_SHADOW: if (texture) { Vector2 shadowOffset(0.5f / texture->GetWidth(), 0.5f / texture->GetHeight()); material->SetShaderParameter("ShadowOffset", shadowOffset); } material->SetShaderParameter("ShadowColor", GetEffectColor()); break; case TE_STROKE: material->SetShaderParameter("StrokeColor", GetEffectColor()); break; default: break; } } } }
void Screen3D::DrawSpriteNoHandle( RECT& Dimensions, Texture* Image, bool StretchTexture, D3DCOLOR color, bool SetAlphaStates) { SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID ); //Figure out the size of the texture (if there is a texture) Texture* T = Image; Real texturewidth=1, textureheight=1; if(T) { texturewidth = T->GetWidth(); textureheight = T->GetHeight(); } // Figure out the vertices for the main window ScreenVertex WindowVertices[4]; WindowVertices[0].z = 0;WindowVertices[1].z = 0;WindowVertices[2].z = 0;WindowVertices[3].z = 0; WindowVertices[0].RHW = 1; WindowVertices[1].RHW = 1; WindowVertices[2].RHW = 1; WindowVertices[3].RHW = 1; WindowVertices[0].color = color;WindowVertices[1].color = color; WindowVertices[2].color = color;WindowVertices[3].color = color; WindowVertices[0].x = Dimensions.left; WindowVertices[0].y = Dimensions.top; WindowVertices[1].x = Dimensions.right; WindowVertices[1].y = Dimensions.top; WindowVertices[2].x = Dimensions.left; WindowVertices[2].y = Dimensions.bottom; WindowVertices[3].x = Dimensions.right; WindowVertices[3].y = Dimensions.bottom; if( StretchTexture ) { WindowVertices[0].tu = 0; WindowVertices[0].tv = 0; WindowVertices[1].tu = 1; WindowVertices[1].tv = 0; WindowVertices[2].tu = 0; WindowVertices[2].tv = 1; WindowVertices[3].tu = 1; WindowVertices[3].tv = 1; } else { WindowVertices[0].tu = 0; WindowVertices[0].tv = 0; WindowVertices[1].tu = (Dimensions.right-Dimensions.left) / texturewidth; WindowVertices[1].tv = 0; WindowVertices[2].tu = 0; WindowVertices[2].tv = (Dimensions.bottom-Dimensions.top) / textureheight; WindowVertices[3].tu = (Dimensions.right-Dimensions.left) / texturewidth; WindowVertices[3].tv = (Dimensions.bottom-Dimensions.top) / textureheight; } PolygonsRendered += 2; DrawCalls++; SetTexture(Image, 0); if(SetAlphaStates) { D3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); D3DDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA); D3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA); } SetFVF(D3DFVF_SCREENVERTEX); D3DDevice->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, 2, WindowVertices, sizeof(ScreenVertex)); }
void Weapon::DrawHUD( Screen3D& Screen, MeshManager& MM, FontManager& FM, Camera& Viewer ) { HitPlayer = false; Screen.Clear(true); // Set the matrices to the origin D3DXMATRIX matWorld; D3DXMatrixIdentity( &matWorld ); Screen.SetTransform( matWorld ); //Set render states ScreenPtr->D3DDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE ); ScreenPtr->D3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE ); ScreenPtr->D3DDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE ); ScreenPtr->D3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE ); ScreenPtr->D3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE ); ScreenPtr->D3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE ); ScreenPtr->D3DDevice->SetTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE ); ScreenPtr->D3DDevice->SetTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE ); ScreenPtr->D3DDevice->SetTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT ); ScreenPtr->D3DDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE ); //Draw the weapon model WeaponFont = FM.GetFont("Lucida Console", 16); Screen.D3DDevice->SetRenderState( D3DRS_FOGENABLE, FALSE ); Matrix ViewMatrix = Viewer.GetLookAtMatrix( -10 ); Matrix WorldMatrix; Matrix DisplacementMat; Matrix DisplacementMat2; Matrix ScaleMatrix; Screen.SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); Screen.SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE); Screen.SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE); Screen.SetRenderState(D3DRS_ALPHATESTENABLE, FALSE ); Screen.SetRenderState(D3DRS_ZENABLE, FALSE ); RECT muzzleDim = { Screen.GetWidth()/2, Screen.GetHeight()/2-Screen.GetHeight()/5,Screen.GetWidth()/2+(Screen.GetHeight()/5)*2, Screen.GetHeight()/2+Screen.GetHeight()/5}; int fade = (int)(MuzzleFlashFade*255.0f); Screen.DrawSpriteRect( muzzleDim, MuzzleFlash, true, D3DCOLOR_RGBA( fade, fade, fade, fade ) ); Screen.SetRenderState(D3DRS_ZENABLE, TRUE ); Screen.SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW); //Screen.SetTextureMode( TMSphereMap); //Screen.SetTexture(GlossMap, 1); Matrix RMat; RMat.Rotate( Viewer.Yaw, Viewer.Pitch, Viewer.Roll); ScreenPtr->D3DDevice->MultiplyTransform( D3DTS_TEXTURE1, &RMat.Mat ); //draw if(!RightHanded) { //First, apply a -1 scale to the transform //matrix so that the gun draws on the opposite side //(since it's left handed). Also, change the //culling order so it doesn't draw inside out. Screen.SetRenderState( D3DRS_CULLMODE, D3DCULL_CW); DisplacementMat.Translate( 0.10f, 3.1f, -4.3f); ScaleMatrix.Scale( -1, 1, 1 ); D3DXMatrixMultiply(&DisplacementMat.Mat, &DisplacementMat.Mat, &ScaleMatrix.Mat); D3DXMatrixMultiply(&ViewMatrix.Mat, &ViewMatrix.Mat, &DisplacementMat.Mat); D3DXMatrixInverse(&WorldMatrix.Mat, NULL, &ViewMatrix.Mat); Screen.SetTransform(WorldMatrix); //Draw the mesh now and return the culling state //DisplayMesh.Draw( Screen ); Screen.SetRenderState(D3DRS_LIGHTING, FALSE ); MeshA.Draw( Screen, WorldMatrix ); Screen.SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW); D3DMATRIX OldState; Screen.D3DDevice->GetTransform( D3DTS_VIEW, &OldState); Matrix I; Screen.SetViewTransform(I); Smoke.MoveSpawn( -1.0f, -1.2f, 9.0f); Smoke.Draw( Screen, Viewer ); if(DualWeapons) { Smoke.MoveSpawn( 1.0f, -1.1f, 8.0f); Smoke.Draw( Screen, Viewer ); } Screen.D3DDevice->SetTransform( D3DTS_VIEW, &OldState); } else { DisplacementMat.Translate( -0.10f, 3.1f, -4.3f); D3DXMatrixMultiply(&ViewMatrix.Mat, &ViewMatrix.Mat, &DisplacementMat.Mat); D3DXMatrixInverse(&WorldMatrix.Mat, NULL, &ViewMatrix.Mat); Screen.SetTransform(WorldMatrix); //Draw the weapon Screen.D3DDevice->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE ); MeshA.Draw( Screen, WorldMatrix ); Screen.D3DDevice->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR ); Matrix I; Screen.SetViewTransform(I); Smoke.MoveSpawn( 1.0f, -1.1f, 8.0f); Smoke.Draw( Screen, Viewer ); if(DualWeapons) { Smoke.MoveSpawn( -1.0f, -1.1f, 8.0f); Smoke.Draw( Screen, Viewer ); } } //Show the ammo information by the weapon Screen.D3DDevice->SetRenderState( D3DRS_FOGENABLE, FALSE ); ScreenPtr->D3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT); ScreenPtr->D3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT); ScreenPtr->D3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE); Screen.SetRenderState(D3DRS_ZENABLE, FALSE ); if(ShowAmmoAmount) { TextureHandle hAmmoBox = Screen.GetTextureHandle( "..\\base\\art\\UI\\icons\\ammobox.bmp", "..\\base\\art\\UI\\icons\\ammobox_a.bmp"); Screen.DrawSprite( Screen.GetWidth() - 145.0f, (Real)Screen.GetHeight() - 40.0f, Screen.TM.GetTexture( hAmmoBox )); WeaponFont->Draw(Screen, Screen.GetWidth() - 105.0f, (Real)Screen.GetHeight() - 32.0f, false, D3DCOLOR_RGBA(255, 255, 255, 255), "%d", ClipAmmo); WeaponFont->Draw(Screen, Screen.GetWidth() - 60.0f, (Real)Screen.GetHeight() - 32.0f, false, D3DCOLOR_RGBA(255, 0, 0, 255), "%d", Ammo); } Screen.TM.SetTextureMode( TMNormal, 0, true); //draw the aimer if(ShowAmmoAmount) { Texture* AimerPtr = Screen.TM.GetTexture( Aimer ); Screen.SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); Screen.SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA); Screen.SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA); Screen.SetRenderState(D3DRS_ALPHATESTENABLE, FALSE ); RECT Dimensions; Dimensions.left = Screen.GetWidth() /2 - (AimerPtr->GetWidth()/2); Dimensions.top = Screen.GetHeight()/2 - (AimerPtr->GetHeight()/2); Dimensions.right = Screen.GetWidth() /2 + AimerPtr->GetWidth()/2-1; Dimensions.bottom = Screen.GetHeight()/2 + AimerPtr->GetHeight()/2-1; if(AimerPtr) Screen.DrawSprite(Screen.GetWidth()/2 - (AimerPtr->GetWidth()/2), Screen.GetHeight()/2 - (AimerPtr->GetHeight()/2), AimerPtr); } ScreenPtr->D3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR); ScreenPtr->D3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR); ScreenPtr->D3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR); Screen.SetRenderState(D3DRS_ZENABLE, TRUE ); Screen.SetRenderState( D3DRS_FOGENABLE, TRUE ); }
void Postprocessing_DrawRainyGlass(Texture& renderTarget, Texture& scene) { Texture dropletTarget = RenderTexturePool::Get(256, 256); // Clear droplet render target to default front-facing direction const Color frontClearColor(0.5f /* x == 0 */, 0.5f /* y = 0 */, 1.0f /* z = 1 */, 0.0f); dropletTarget.BeginDrawing(&frontClearColor); // Evaporation if (rain->dropletBuffer.IsValid()) { if (rain->rainEvaporation > 0.02f) // Apply rain evaporation { rain->material.SetTechnique("rain_evaporation"); rain->rainEvaporation = 0; } else // Just copy previous buffer (skip evaporation step this time) { rain->material.SetTechnique("copy_texture"); } rain->material.SetTextureParameter("ColorMap", rain->dropletBuffer, Sampler::DefaultPostprocess); rain->material.DrawFullscreenQuad(); } // Droplets const Vec2 sizeScale( (float) dropletTarget.GetWidth(), (float) dropletTarget.GetHeight() ); while (rain->deltaTime > 0.0f) { const float stepDeltaTime = min(rain->deltaTime, 1 / 60.0f); rain->deltaTime -= stepDeltaTime; Postprocessing_UpdateRainyGlassStep(stepDeltaTime); const unsigned int numDroplets = rain->droplets.size(); if (!numDroplets) continue; std::vector<Vec2> verts(numDroplets * 4); std::vector<Vec2> tex(numDroplets * 4); std::vector<unsigned short> indices(numDroplets * 6); int currVertexIndex = 0; unsigned short* currIndex = &indices[0]; std::vector<RainyGlass::Droplet>::iterator dropletsEnd = rain->droplets.end(); for (std::vector<RainyGlass::Droplet>::iterator it = rain->droplets.begin(); it != dropletsEnd; ++it) { Vec2 size = Vec2(it->size, it->size); Vec2 pos = it->pos - size * 0.5f; size *= sizeScale; pos *= sizeScale; Vec2* currVertex = &verts[currVertexIndex]; *(currVertex++) = pos; *(currVertex++) = pos + Vec2(size.x, 0.0f); *(currVertex++) = pos + size; *(currVertex++) = pos + Vec2(0.0f, size.y); Vec2* currTex = &tex[currVertexIndex]; (currTex++)->Set(0.0f, 0.0f); (currTex++)->Set(1.0f, 0.0f); (currTex++)->Set(1.0f, 1.0f); (currTex++)->Set(0.0f, 1.0f); *(currIndex++) = currVertexIndex; *(currIndex++) = currVertexIndex + 1; *(currIndex++) = currVertexIndex + 2; *(currIndex++) = currVertexIndex; *(currIndex++) = currVertexIndex + 2; *(currIndex++) = currVertexIndex + 3; currVertexIndex += 4; } Shape::DrawParams drawParams; drawParams.SetGeometryType(Shape::Geometry::Type_Triangles); drawParams.SetNumVerts(verts.size()); drawParams.SetPosition(&verts[0], sizeof(Vec2)); drawParams.SetTexCoord(&tex[0], 0, sizeof(Vec2)); drawParams.SetIndices(indices.size(), &indices[0]); Material& defaultMaterial = App::GetDefaultMaterial(); defaultMaterial.SetTechnique("tex_col"); defaultMaterial.SetFloatParameter("Color", (const float*) &Color::White, 4); defaultMaterial.SetTextureParameter("ColorMap", rain->dropletTexture); defaultMaterial.Draw(&drawParams); } dropletTarget.EndDrawing(); // Swap droplet buffer if (rain->dropletBuffer.IsValid()) RenderTexturePool::Release(rain->dropletBuffer); rain->dropletBuffer = dropletTarget; // Apply droplet buffer distortion to scene renderTarget.BeginDrawing(); Sampler colorSampler = Sampler::DefaultPostprocess; colorSampler.minFilterLinear = true; colorSampler.magFilterLinear = true; rain->material.SetTechnique("rain_distortion"); rain->material.SetFloatParameter("DropletColor", (const float*) &rain->dropletColor, 4); rain->material.SetTextureParameter("ColorMap", scene, colorSampler); rain->material.SetTextureParameter("NormalMap", rain->dropletBuffer); rain->material.DrawFullscreenQuad(); renderTarget.EndDrawing(); }
void Text::UpdateText(const std::string &text,const Vec4 &color) { if (this->text!=text) { this->text = text; if (Initialized) { geometry->Dispose(); geometry->index.clear(); geometry->tVertex.clear(); geometry->tNormal.clear(); geometry->tTexcoord.clear(); } Initialized = true; f32 width = 0.0f; f32 height = 0.0f; f32 offsetX = 0; f32 offsetY = 0; uint32 quads = 0; f32 lineSize = 0.0f; for (uint32 i = 0;i<text.size();i++) { switch(text[i]) { case '\n': // Build Quads in the bottom offsetY-=lineSize*1.5f; offsetX = 0.0f; break; case ' ': offsetX+=font->GetFontSize()/2; break; default: glyph_properties glp = font->GetGlyphs()[text[i]]; width = glp.size.x; height = glp.size.y; // Build Quads to the right f32 w2 = width; f32 h2 = height; if (height + glp.offset.y >lineSize) lineSize = height + glp.offset.y; Vec3 a = Vec3(offsetX, offsetY-glp.offset.y ,0); Vec3 b = Vec3(w2+offsetX, offsetY-glp.offset.y ,0); Vec3 c = Vec3(w2+offsetX, h2+offsetY-glp.offset.y ,0); Vec3 d = Vec3(offsetX, h2+offsetY-glp.offset.y ,0); // Apply Dimensions a.x = charWidth * a.x / font->GetFontSize(); a.y = charHeight * a.y / font->GetFontSize(); b.x = charWidth * b.x / font->GetFontSize(); b.y = charHeight * b.y / font->GetFontSize(); c.x = charWidth * c.x / font->GetFontSize(); c.y = charHeight * c.y / font->GetFontSize(); d.x = charWidth * d.x / font->GetFontSize(); d.y = charHeight * d.y / font->GetFontSize(); Vec3 normal = Vec3(color.x,color.y,color.z); geometry->tVertex.push_back(a); geometry->tNormal.push_back(normal); geometry->tVertex.push_back(b); geometry->tNormal.push_back(normal); geometry->tVertex.push_back(c); geometry->tNormal.push_back(normal); geometry->tVertex.push_back(d); geometry->tNormal.push_back(normal); Texture* t = font->GetTexture(); geometry->tTexcoord.push_back(Vec2(glp.startingPoint.x,glp.startingPoint.y + glp.size.y/(f32)t->GetHeight())); geometry->tTexcoord.push_back(Vec2(glp.startingPoint.x + glp.size.x/(f32)t->GetWidth(),glp.startingPoint.y + glp.size.y/(f32)t->GetHeight())); geometry->tTexcoord.push_back(Vec2(glp.startingPoint.x + glp.size.x/(f32)t->GetWidth(),glp.startingPoint.y)); geometry->tTexcoord.push_back(Vec2(glp.startingPoint.x,glp.startingPoint.y)); geometry->index.push_back(quads*4+0); geometry->index.push_back(quads*4+1); geometry->index.push_back(quads*4+2); geometry->index.push_back(quads*4+2); geometry->index.push_back(quads*4+3); geometry->index.push_back(quads*4+0); offsetX+=width + glp.offset.x; quads++; break; } } // Build and Send Buffers Build(); } }
void EditorLandscape::DrawFullTiledTexture(DAVA::Texture *renderTarget, const DAVA::Rect &drawRect) { Texture *fullTiledTexture = nestedLandscape->GetTexture(Landscape::TEXTURE_TILE_FULL); Sprite *background = Sprite::CreateFromTexture(fullTiledTexture, 0, 0, (float32)fullTiledTexture->GetWidth(), (float32)fullTiledTexture->GetHeight()); background->SetPosition(0.f, 0.f); background->SetScaleSize((float32)renderTarget->GetWidth(), (float32)renderTarget->GetHeight()); background->Draw(); SafeRelease(background); }
void Screen3D::DrawSprite( int x, int y, Texture* Image, int alpha) { SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID ); Texture* T = Image; Real texturewidth=1, textureheight=1; if(T) { texturewidth = T->GetWidth(); textureheight = T->GetHeight(); } //float jiggle= (rand() % 10000) - 5000; //jiggle /= 5000.0f; float jiggle = 0.5f; if( alpha != 255 ) jiggle = 0; x--; y--; ScreenVertex v[6]; D3DCOLOR color = D3DCOLOR_ARGB( alpha, 255, 255, 255 ); v[0] = ScreenVertex( x+jiggle, y+jiggle, 1, color, 0, 0 ); v[2] = ScreenVertex( x+jiggle+texturewidth, y+textureheight, 1, color, 1, 1 ); v[1] = ScreenVertex( x+jiggle, y+jiggle+textureheight, 1, color, 0, 1 ); v[3] = ScreenVertex( x+jiggle, y+jiggle, 1, color, 0, 0 ); v[5] = ScreenVertex( x+jiggle+texturewidth, y+jiggle, 1, color, 1, 0 ); v[4] = ScreenVertex( x+jiggle+texturewidth, y+textureheight+jiggle, 1, color, 1, 1 ); SetTexture(Image, 0); SetFVF(D3DFVF_SCREENVERTEX); SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); // D3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); // D3DDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA); //D3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA); D3DDevice->DrawPrimitiveUP( D3DPT_TRIANGLELIST, 2, v, sizeof(ScreenVertex)); ResetWireframeState(); // Figure out the vertices for the main window /*ScreenVertex WindowVertices[4]; WindowVertices[0].z = 0;WindowVertices[1].z = 0;WindowVertices[2].z = 0;WindowVertices[3].z = 0; WindowVertices[0].RHW = 1; WindowVertices[1].RHW = 1; WindowVertices[2].RHW = 1; WindowVertices[3].RHW = 1; WindowVertices[0].color = D3DCOLOR_RGBA(255, 255, 255, alpha);WindowVertices[1].color = D3DCOLOR_RGBA(255, 255, 255, alpha); WindowVertices[2].color = D3DCOLOR_RGBA(255, 255, 255, alpha);WindowVertices[3].color = D3DCOLOR_RGBA(255, 255, 255, alpha); WindowVertices[0].x = x; WindowVertices[0].y = y; WindowVertices[1].x = x+texturewidth; WindowVertices[1].y = y; WindowVertices[2].x = x; WindowVertices[2].y = y+textureheight; WindowVertices[3].x = x+texturewidth; WindowVertices[3].y = y+textureheight; WindowVertices[0].tu = 0; WindowVertices[0].tv = 0; WindowVertices[1].tu = 1; WindowVertices[1].tv = 0; WindowVertices[2].tu = 0; WindowVertices[2].tv = 1; WindowVertices[3].tu = 1; WindowVertices[3].tv = 1; SetTexture(Image, 0); D3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); D3DDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA); D3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA); SetFVF(D3DFVF_SCREENVERTEX); D3DDevice->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, 2, WindowVertices, sizeof(ScreenVertex));*/ }
JNIEXPORT jint JNICALL Java_sp_graphics_Texture_native_1getHeight (JNIEnv *env, jclass cls, jlong handler) { Texture* texture = getHandle<Texture>(handler); return texture->GetHeight(); }
Cursor * Cursor::Create(const String & cursorPathname, const Vector2 & hotSpot) { //const String & realPath = FileSystem::Instance()->SystemPathForFrameworkPath(cursorPathname); Texture * cursorTexture = Texture::CreateFromFile(cursorPathname); if (!cursorTexture)return 0; Cursor * cursor = new Cursor(); cursor->cursorTexture = cursorTexture; cursor->hotSpot = hotSpot; //Sprite * cursorSprite = Sprite::Create("~res:/Gfx/upgrade/list");//Sprite::CreateFromTexture(cursorTexture, 0, 0, cursorTexture->GetWidth(), cursorTexture->GetHeight()); Sprite * cursorSprite = Sprite::CreateFromTexture(cursorTexture, 0, 0, (float32)cursorTexture->GetWidth(), (float32)cursorTexture->GetHeight()); cursor->cursorSprite = cursorSprite; cursorSprite->SetDefaultPivotPoint(hotSpot); cursorSprite->Reset(); return cursor; }
void Text3D::UpdateTextMaterials(bool forceUpdate) { Font* font = GetFont(); bool isSDFFont = font ? font->IsSDFFont() : false; batches_.Resize(uiBatches_.Size()); geometries_.Resize(uiBatches_.Size()); for (unsigned i = 0; i < batches_.Size(); ++i) { if (!geometries_[i]) { Geometry* geometry = new Geometry(context_); geometry->SetVertexBuffer(0, vertexBuffer_); batches_[i].geometry_ = geometries_[i] = geometry; } if (!batches_[i].material_ || forceUpdate || isSDFFont != usingSDFShader_) { // If material not defined, create a reasonable default from scratch if (!material_) { Material* material = new Material(context_); Technique* tech = new Technique(context_); Pass* pass = tech->CreatePass("alpha"); pass->SetVertexShader("Text"); pass->SetPixelShader("Text"); if (isSDFFont) { switch (GetTextEffect()) { case TE_NONE: pass->SetPixelShaderDefines("SIGNED_DISTANCE_FIELD"); break; case TE_SHADOW: pass->SetPixelShaderDefines("SIGNED_DISTANCE_FIELD TEXT_EFFECT_SHADOW"); break; case TE_STROKE: pass->SetPixelShaderDefines("SIGNED_DISTANCE_FIELD TEXT_EFFECT_STROKE"); break; } } pass->SetBlendMode(BLEND_ALPHA); pass->SetDepthWrite(false); material->SetTechnique(0, tech); material->SetCullMode(CULL_NONE); batches_[i].material_ = material; } else batches_[i].material_ = material_->Clone(); // Note: custom material is assumed to use the right kind of shader; it is not modified to define SIGNED_DISTANCE_FIELD usingSDFShader_ = isSDFFont; } Material* material = batches_[i].material_; Texture* texture = uiBatches_[i].texture_; material->SetTexture(TU_DIFFUSE, texture); if (isSDFFont) { switch (GetTextEffect()) { case TE_SHADOW: if (texture) { Vector2 shadowOffset(0.5f / texture->GetWidth(), 0.5f / texture->GetHeight()); material->SetShaderParameter("ShadowOffset", shadowOffset); } material->SetShaderParameter("ShadowColor", GetEffectColor()); break; case TE_STROKE: material->SetShaderParameter("StrokeColor", GetEffectColor()); break; default: break; } } } }
float GetHeight(void) const { return (float) Image->GetHeight(); }