mirror of
https://github.com/ZDoom/Raze.git
synced 2025-01-07 09:40:43 +00:00
251 lines
6.7 KiB
C++
251 lines
6.7 KiB
C++
/*
|
|
** animtexture.cpp
|
|
**
|
|
**---------------------------------------------------------------------------
|
|
** Copyright 2020 Christoph Oelckers
|
|
** All rights reserved.
|
|
**
|
|
** Redistribution and use in source and binary forms, with or without
|
|
** modification, are permitted provided that the following conditions
|
|
** are met:
|
|
**
|
|
** 1. Redistributions of source code must retain the above copyright
|
|
** notice, this list of conditions and the following disclaimer.
|
|
** 2. 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.
|
|
** 3. The name of the author may not be used to endorse or promote products
|
|
** derived from this software without specific prior written permission.
|
|
**
|
|
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 "animtexture.h"
|
|
#include "bitmap.h"
|
|
#include "texturemanager.h"
|
|
|
|
#include "vpx/vpx_image.h"
|
|
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
|
|
void AnimTexture::SetFrameSize(int format, int width, int height)
|
|
{
|
|
pixelformat = format;
|
|
FTexture::SetSize(width, height);
|
|
Image.Resize(width * height * 4);
|
|
memset(Image.Data(), 0, Image.Size());
|
|
}
|
|
|
|
//TODO optimize
|
|
static inline void YUVtoRGB(uint8_t yi, uint8_t ui, uint8_t vi, uint8_t * rgb)
|
|
{
|
|
float Y = yi * (1 / 255.f);
|
|
float U = ui * (1 / 255.f) - 0.5f;
|
|
float V = vi * (1 / 255.f) - 0.5f;
|
|
Y = 1.1643f * (Y - 0.0625f);
|
|
float r = Y + 1.5958f * V;
|
|
float g = Y - 0.39173f * U - 0.81290f * V;
|
|
float b = Y + 2.017f * U;
|
|
(rgb)[2] = (uint8_t)(clamp(r, 0.f, 1.f) * 255);
|
|
(rgb)[1] = (uint8_t)(clamp(g, 0.f, 1.f) * 255);
|
|
(rgb)[0] = (uint8_t)(clamp(b, 0.f, 1.f) * 255);
|
|
(rgb)[3] = 255;
|
|
}
|
|
|
|
void AnimTexture::SetFrame(const uint8_t* Palette, const void* data_)
|
|
{
|
|
if (data_)
|
|
{
|
|
auto dpix = Image.Data();
|
|
|
|
if (pixelformat == YUV)
|
|
{
|
|
const uint8_t * spix = reinterpret_cast<const uint8_t *>(data_);
|
|
|
|
for (int i = 0; i < Width * Height; i++)
|
|
{
|
|
YUVtoRGB(spix[0], spix[1], spix[2], dpix);
|
|
|
|
spix += 4;
|
|
dpix += 4;
|
|
}
|
|
}
|
|
else if(pixelformat == VPX)
|
|
{
|
|
const vpx_image_t *img = reinterpret_cast<const vpx_image_t *>(data_);
|
|
|
|
uint8_t const* const yplane = img->planes[VPX_PLANE_Y];
|
|
uint8_t const* const uplane = img->planes[VPX_PLANE_U];
|
|
uint8_t const* const vplane = img->planes[VPX_PLANE_V];
|
|
|
|
const int ystride = img->stride[VPX_PLANE_Y];
|
|
const int ustride = img->stride[VPX_PLANE_U];
|
|
const int vstride = img->stride[VPX_PLANE_V];
|
|
|
|
if(img->fmt == VPX_IMG_FMT_I420)
|
|
{
|
|
for (unsigned int y = 0; y < Height; y++)
|
|
{
|
|
for (unsigned int x = 0; x < Width; x++)
|
|
{
|
|
YUVtoRGB(
|
|
yplane[ystride * y + x],
|
|
uplane[ustride * (y >> 1) + (x >> 1)],
|
|
vplane[vstride * (y >> 1) + (x >> 1)],
|
|
dpix
|
|
);
|
|
|
|
dpix += 4;
|
|
}
|
|
}
|
|
}
|
|
else if(img->fmt == VPX_IMG_FMT_I444)
|
|
{
|
|
for (unsigned int y = 0; y < Height; y++)
|
|
{
|
|
for (unsigned int x = 0; x < Width; x++)
|
|
{
|
|
YUVtoRGB(
|
|
yplane[ystride * y + x],
|
|
uplane[ustride * y + x],
|
|
vplane[vstride * y + x],
|
|
dpix
|
|
);
|
|
dpix += 4;
|
|
}
|
|
}
|
|
}
|
|
else if(img->fmt == VPX_IMG_FMT_I422)
|
|
{ // 422 and 440 untested
|
|
for (unsigned int y = 0; y < Height; y++)
|
|
{
|
|
for (unsigned int x = 0; x < Width; x++)
|
|
{
|
|
YUVtoRGB(
|
|
yplane[ystride * y + x],
|
|
uplane[ustride * y + (x >> 1)],
|
|
vplane[vstride * y + (x >> 1)],
|
|
dpix
|
|
);
|
|
dpix += 4;
|
|
}
|
|
}
|
|
}
|
|
else if(img->fmt == VPX_IMG_FMT_I440)
|
|
{
|
|
for (unsigned int y = 0; y < Height; y++)
|
|
{
|
|
for (unsigned int x = 0; x < Width; x++)
|
|
{
|
|
YUVtoRGB(
|
|
yplane[ystride * y + x],
|
|
uplane[ustride * (y >> 1) + x],
|
|
vplane[vstride * (y >> 1) + x],
|
|
dpix
|
|
);
|
|
dpix += 4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(pixelformat == RGB)
|
|
{
|
|
const uint8_t *img = reinterpret_cast<const uint8_t *>(data_);
|
|
|
|
for (int i = 0; i < Width * Height; i++)
|
|
{
|
|
dpix[0] = img[2];
|
|
dpix[1] = img[1];
|
|
dpix[2] = img[0];
|
|
dpix[3] = 255;
|
|
|
|
dpix += 4;
|
|
}
|
|
}
|
|
else if (pixelformat == Paletted)
|
|
{
|
|
assert(Palette);
|
|
const uint8_t *img = reinterpret_cast<const uint8_t *>(data_);
|
|
|
|
for (int i = 0; i < Width * Height; i++)
|
|
{
|
|
int index = img[i];
|
|
dpix[0] = Palette[index * 3 + 2];
|
|
dpix[1] = Palette[index * 3 + 1];
|
|
dpix[2] = Palette[index * 3];
|
|
dpix[3] = 255;
|
|
|
|
dpix += 4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//===========================================================================
|
|
//
|
|
// FPNGTexture::CopyPixels
|
|
//
|
|
//===========================================================================
|
|
|
|
FBitmap AnimTexture::GetBgraBitmap(const PalEntry* remap, int* trans)
|
|
{
|
|
return FBitmap(Image.Data(), Width * 4, Width, Height);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
//
|
|
//
|
|
//==========================================================================
|
|
|
|
AnimTextures::AnimTextures()
|
|
{
|
|
active = 1;
|
|
tex[0] = TexMan.FindGameTexture("AnimTextureFrame1", ETextureType::Override);
|
|
tex[1] = TexMan.FindGameTexture("AnimTextureFrame2", ETextureType::Override);
|
|
}
|
|
|
|
AnimTextures::~AnimTextures()
|
|
{
|
|
Clean();
|
|
}
|
|
|
|
void AnimTextures::Clean()
|
|
{
|
|
if (tex[0]) tex[0]->CleanHardwareData(true);
|
|
if (tex[1]) tex[1]->CleanHardwareData(true);
|
|
tex[0] = tex[1] = nullptr;
|
|
}
|
|
|
|
void AnimTextures::SetSize(int format, int width, int height)
|
|
{
|
|
static_cast<AnimTexture*>(tex[0]->GetTexture())->SetFrameSize(format, width, height);
|
|
static_cast<AnimTexture*>(tex[1]->GetTexture())->SetFrameSize(format, width, height);
|
|
tex[0]->SetSize(width, height);
|
|
tex[1]->SetSize(width, height);
|
|
tex[0]->CleanHardwareData();
|
|
tex[1]->CleanHardwareData();
|
|
}
|
|
|
|
void AnimTextures::SetFrame(const uint8_t* palette, const void* data)
|
|
{
|
|
active ^= 1;
|
|
static_cast<AnimTexture*>(tex[active]->GetTexture())->SetFrame(palette, data);
|
|
tex[active]->CleanHardwareData();
|
|
}
|