Emulator-Archive/ppsspp
1
0
Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2025-02-22 23:22:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Introduce fake vertex decoder JIT as well.

Browse Source 
Compiles and links on CI20 but gets unknown crash in GL driver.
This commit is contained in:
xSacha 2014-11-13 17:10:29 +10:00
parent c421617c84
commit 57e4088216
10 changed files with 392 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
Common/FakeCPUDetect.cpp Normal file
View File

@ -0,0 +1,50 @@
// Copyright (C) 2003 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#include <memory.h>
#include "base/logging.h"
#include "base/basictypes.h"
#include "Common.h"
#include "CPUDetect.h"
#include "StringUtils.h"
CPUInfo cpu_info;
CPUInfo::CPUInfo() {
Detect();
}
// Detects the various cpu features
void CPUInfo::Detect()
{
memset(this, 0, sizeof(*this));
num_cores = 1;
strcpy(cpu_string, "Unknown");
strcpy(brand_string, "Unknown");
HTT = false;
logical_cpu_count = 2;
}
// Turn the cpu info into a string we can show
std::string CPUInfo::Summarize()
{
std::string sum;
sum = StringFromFormat("%s, %i core", cpu_string, num_cores);
return sum;
}

7
Common/FakeEmitter.h
View File

@ -324,13 +324,6 @@ struct FixupBranch
int type; //0 = B 1 = BL
};
struct LiteralPool
{
intptr_t loc;
u8* ldr_address;
u32 val;
};
typedef const u8* JumpTarget;
// XXX: Stop polluting the global namespace

4
Core/MIPS/fake/FakeJit.cpp
View File

@ -100,7 +100,6 @@ void Jit::ClearCache()
{
blocks.Clear();
ClearCodeSpace();
GenerateFixedCode();
}
void Jit::InvalidateCache()
@ -165,7 +164,6 @@ void Jit::Comp_Generic(MIPSOpcode op)
if (func)
{
SaveDowncount();
QuickCallFunction(R1, (void *)func);
RestoreDowncount();
}
@ -218,8 +216,6 @@ void Jit::WriteSyscallExit()
{
}
void Jit::Comp_DoNothing(MIPSOpcode op) { }
#define _RS ((op>>21) & 0x1F)
#define _RT ((op>>16) & 0x1F)
#define _RD ((op>>11) & 0x1F)

158
Core/MIPS/fake/FakeJit.h
View File

@ -72,110 +72,72 @@ public:
void Comp_ReplacementFunc(MIPSOpcode op);
// Ops
void Comp_ITypeMem(MIPSOpcode op);
void Comp_Cache(MIPSOpcode op);
void Comp_ITypeMem(MIPSOpcode op) {}
void Comp_Cache(MIPSOpcode op) {}
void Comp_RelBranch(MIPSOpcode op);
void Comp_RelBranchRI(MIPSOpcode op);
void Comp_FPUBranch(MIPSOpcode op);
void Comp_FPULS(MIPSOpcode op);
void Comp_FPUComp(MIPSOpcode op);
void Comp_Jump(MIPSOpcode op);
void Comp_JumpReg(MIPSOpcode op);
void Comp_Syscall(MIPSOpcode op);
void Comp_Break(MIPSOpcode op);
void Comp_RelBranch(MIPSOpcode op) {}
void Comp_RelBranchRI(MIPSOpcode op) {}
void Comp_FPUBranch(MIPSOpcode op) {}
void Comp_FPULS(MIPSOpcode op) {}
void Comp_FPUComp(MIPSOpcode op) {}
void Comp_Jump(MIPSOpcode op) {}
void Comp_JumpReg(MIPSOpcode op) {}
void Comp_Syscall(MIPSOpcode op) {}
void Comp_Break(MIPSOpcode op) {}
void Comp_IType(MIPSOpcode op);
void Comp_RType2(MIPSOpcode op);
void Comp_RType3(MIPSOpcode op);
void Comp_ShiftType(MIPSOpcode op);
void Comp_Allegrex(MIPSOpcode op);
void Comp_Allegrex2(MIPSOpcode op);
void Comp_VBranch(MIPSOpcode op);
void Comp_MulDivType(MIPSOpcode op);
void Comp_Special3(MIPSOpcode op);
void Comp_IType(MIPSOpcode op) {}
void Comp_RType2(MIPSOpcode op) {}
void Comp_RType3(MIPSOpcode op) {}
void Comp_ShiftType(MIPSOpcode op) {}
void Comp_Allegrex(MIPSOpcode op) {}
void Comp_Allegrex2(MIPSOpcode op) {}
void Comp_VBranch(MIPSOpcode op) {}
void Comp_MulDivType(MIPSOpcode op) {}
void Comp_Special3(MIPSOpcode op) {}
void Comp_FPU3op(MIPSOpcode op);
void Comp_FPU2op(MIPSOpcode op);
void Comp_mxc1(MIPSOpcode op);
void Comp_FPU3op(MIPSOpcode op) {}
void Comp_FPU2op(MIPSOpcode op) {}
void Comp_mxc1(MIPSOpcode op) {}
void Comp_DoNothing(MIPSOpcode op);
void Comp_DoNothing(MIPSOpcode op) {}
void Comp_SV(MIPSOpcode op);
void Comp_SVQ(MIPSOpcode op);
void Comp_VPFX(MIPSOpcode op);
void Comp_VVectorInit(MIPSOpcode op);
void Comp_VMatrixInit(MIPSOpcode op);
void Comp_VDot(MIPSOpcode op);
void Comp_VecDo3(MIPSOpcode op);
void Comp_VV2Op(MIPSOpcode op);
void Comp_Mftv(MIPSOpcode op);
void Comp_Vmfvc(MIPSOpcode op);
void Comp_Vmtvc(MIPSOpcode op);
void Comp_Vmmov(MIPSOpcode op);
void Comp_VScl(MIPSOpcode op);
void Comp_Vmmul(MIPSOpcode op);
void Comp_Vmscl(MIPSOpcode op);
void Comp_Vtfm(MIPSOpcode op);
void Comp_VHdp(MIPSOpcode op);
void Comp_VCrs(MIPSOpcode op);
void Comp_VDet(MIPSOpcode op);
void Comp_Vi2x(MIPSOpcode op);
void Comp_Vx2i(MIPSOpcode op);
void Comp_Vf2i(MIPSOpcode op);
void Comp_Vi2f(MIPSOpcode op);
void Comp_Vh2f(MIPSOpcode op);
void Comp_Vcst(MIPSOpcode op);
void Comp_Vhoriz(MIPSOpcode op);
void Comp_VRot(MIPSOpcode op);
void Comp_VIdt(MIPSOpcode op);
void Comp_Vcmp(MIPSOpcode op);
void Comp_Vcmov(MIPSOpcode op);
void Comp_Viim(MIPSOpcode op);
void Comp_Vfim(MIPSOpcode op);
void Comp_VCrossQuat(MIPSOpcode op);
void Comp_Vsgn(MIPSOpcode op);
void Comp_Vocp(MIPSOpcode op);
void Comp_SV(MIPSOpcode op) {}
void Comp_SVQ(MIPSOpcode op) {}
void Comp_VPFX(MIPSOpcode op) {}
void Comp_VVectorInit(MIPSOpcode op) {}
void Comp_VMatrixInit(MIPSOpcode op) {}
void Comp_VDot(MIPSOpcode op) {}
void Comp_VecDo3(MIPSOpcode op) {}
void Comp_VV2Op(MIPSOpcode op) {}
void Comp_Mftv(MIPSOpcode op) {}
void Comp_Vmfvc(MIPSOpcode op) {}
void Comp_Vmtvc(MIPSOpcode op) {}
void Comp_Vmmov(MIPSOpcode op) {}
void Comp_VScl(MIPSOpcode op) {}
void Comp_Vmmul(MIPSOpcode op) {}
void Comp_Vmscl(MIPSOpcode op) {}
void Comp_Vtfm(MIPSOpcode op) {}
void Comp_VHdp(MIPSOpcode op) {}
void Comp_VCrs(MIPSOpcode op) {}
void Comp_VDet(MIPSOpcode op) {}
void Comp_Vi2x(MIPSOpcode op) {}
void Comp_Vx2i(MIPSOpcode op) {}
void Comp_Vf2i(MIPSOpcode op) {}
void Comp_Vi2f(MIPSOpcode op) {}
void Comp_Vh2f(MIPSOpcode op) {}
void Comp_Vcst(MIPSOpcode op) {}
void Comp_Vhoriz(MIPSOpcode op) {}
void Comp_VRot(MIPSOpcode op) {}
void Comp_VIdt(MIPSOpcode op) {}
void Comp_Vcmp(MIPSOpcode op) {}
void Comp_Vcmov(MIPSOpcode op) {}
void Comp_Viim(MIPSOpcode op) {}
void Comp_Vfim(MIPSOpcode op) {}
void Comp_VCrossQuat(MIPSOpcode op) {}
void Comp_Vsgn(MIPSOpcode op) {}
void Comp_Vocp(MIPSOpcode op) {}
// Non-NEON: VPFX
// NEON implementations of the VFPU ops.
void CompNEON_SV(MIPSOpcode op);
void CompNEON_SVQ(MIPSOpcode op);
void CompNEON_VVectorInit(MIPSOpcode op);
void CompNEON_VMatrixInit(MIPSOpcode op);
void CompNEON_VDot(MIPSOpcode op);
void CompNEON_VecDo3(MIPSOpcode op);
void CompNEON_VV2Op(MIPSOpcode op);
void CompNEON_Mftv(MIPSOpcode op);
void CompNEON_Vmfvc(MIPSOpcode op);
void CompNEON_Vmtvc(MIPSOpcode op);
void CompNEON_Vmmov(MIPSOpcode op);
void CompNEON_VScl(MIPSOpcode op);
void CompNEON_Vmmul(MIPSOpcode op);
void CompNEON_Vmscl(MIPSOpcode op);
void CompNEON_Vtfm(MIPSOpcode op);
void CompNEON_VHdp(MIPSOpcode op);
void CompNEON_VCrs(MIPSOpcode op);
void CompNEON_VDet(MIPSOpcode op);
void CompNEON_Vi2x(MIPSOpcode op);
void CompNEON_Vx2i(MIPSOpcode op);
void CompNEON_Vf2i(MIPSOpcode op);
void CompNEON_Vi2f(MIPSOpcode op);
void CompNEON_Vh2f(MIPSOpcode op);
void CompNEON_Vcst(MIPSOpcode op);
void CompNEON_Vhoriz(MIPSOpcode op);
void CompNEON_VRot(MIPSOpcode op);
void CompNEON_VIdt(MIPSOpcode op);
void CompNEON_Vcmp(MIPSOpcode op);
void CompNEON_Vcmov(MIPSOpcode op);
void CompNEON_Viim(MIPSOpcode op);
void CompNEON_Vfim(MIPSOpcode op);
void CompNEON_VCrossQuat(MIPSOpcode op);
void CompNEON_Vsgn(MIPSOpcode op);
void CompNEON_Vocp(MIPSOpcode op);
int Replace_fabsf();
int Replace_fabsf() { return 0; }
JitBlockCache *GetBlockCache() { return &blocks; }

8
GPU/Common/VertexDecoderCommon.h
View File

@ -25,8 +25,10 @@
#include "GPU/ge_constants.h"
#ifdef ARM
#include "Common/ArmEmitter.h"
#else
#elif defined(_M_IX86) || defined(_M_X64)
#include "Common/x64Emitter.h"
#else
#include "Common/FakeEmitter.h"
#endif
#include "Globals.h"
@ -575,8 +577,10 @@ public:
#ifdef ARM
class VertexDecoderJitCache : public ArmGen::ARMXCodeBlock {
#else
#elif defined(_M_IX86) || defined(_M_X64)
class VertexDecoderJitCache : public Gen::XCodeBlock {
#else
class VertexDecoderJitCache : public FakeGen::FakeXCodeBlock {
#endif
public:
VertexDecoderJitCache();

268
GPU/Common/VertexDecoderFake.cpp Normal file
View File

@ -0,0 +1,268 @@
// Copyright (c) 2013- PPSSPP Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0 or later versions.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official git repository and contact information can be found at
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
#include "base/logging.h"
#include "Common/CPUDetect.h"
#include "Core/Config.h"
#include "Core/Reporting.h"
#include "GPU/GPUState.h"
#include "GPU/Common/VertexDecoderCommon.h"
static const float by128 = 1.0f / 128.0f;
static const float by16384 = 1.0f / 16384.0f;
static const float by32768 = 1.0f / 32768.0f;
using namespace FakeGen;
static const JitLookup jitLookup[] = {
{&VertexDecoder::Step_WeightsU8, &VertexDecoderJitCache::Jit_WeightsU8},
{&VertexDecoder::Step_WeightsU16, &VertexDecoderJitCache::Jit_WeightsU16},
{&VertexDecoder::Step_WeightsFloat, &VertexDecoderJitCache::Jit_WeightsFloat},
{&VertexDecoder::Step_WeightsU8Skin, &VertexDecoderJitCache::Jit_WeightsU8Skin},
{&VertexDecoder::Step_WeightsU16Skin, &VertexDecoderJitCache::Jit_WeightsU16Skin},
{&VertexDecoder::Step_WeightsFloatSkin, &VertexDecoderJitCache::Jit_WeightsFloatSkin},
{&VertexDecoder::Step_TcU8, &VertexDecoderJitCache::Jit_TcU8},
{&VertexDecoder::Step_TcU16, &VertexDecoderJitCache::Jit_TcU16},
{&VertexDecoder::Step_TcFloat, &VertexDecoderJitCache::Jit_TcFloat},
{&VertexDecoder::Step_TcU16Double, &VertexDecoderJitCache::Jit_TcU16Double},
{&VertexDecoder::Step_TcU8Prescale, &VertexDecoderJitCache::Jit_TcU8Prescale},
{&VertexDecoder::Step_TcU16Prescale, &VertexDecoderJitCache::Jit_TcU16Prescale},
{&VertexDecoder::Step_TcFloatPrescale, &VertexDecoderJitCache::Jit_TcFloatPrescale},
{&VertexDecoder::Step_TcU16Through, &VertexDecoderJitCache::Jit_TcU16Through},
{&VertexDecoder::Step_TcFloatThrough, &VertexDecoderJitCache::Jit_TcFloatThrough},
{&VertexDecoder::Step_TcU16ThroughDouble, &VertexDecoderJitCache::Jit_TcU16ThroughDouble},
{&VertexDecoder::Step_NormalS8, &VertexDecoderJitCache::Jit_NormalS8},
{&VertexDecoder::Step_NormalS16, &VertexDecoderJitCache::Jit_NormalS16},
{&VertexDecoder::Step_NormalFloat, &VertexDecoderJitCache::Jit_NormalFloat},
{&VertexDecoder::Step_NormalS8Skin, &VertexDecoderJitCache::Jit_NormalS8Skin},
{&VertexDecoder::Step_NormalS16Skin, &VertexDecoderJitCache::Jit_NormalS16Skin},
{&VertexDecoder::Step_NormalFloatSkin, &VertexDecoderJitCache::Jit_NormalFloatSkin},
{&VertexDecoder::Step_Color8888, &VertexDecoderJitCache::Jit_Color8888},
{&VertexDecoder::Step_Color4444, &VertexDecoderJitCache::Jit_Color4444},
{&VertexDecoder::Step_Color565, &VertexDecoderJitCache::Jit_Color565},
{&VertexDecoder::Step_Color5551, &VertexDecoderJitCache::Jit_Color5551},
{&VertexDecoder::Step_PosS8Through, &VertexDecoderJitCache::Jit_PosS8Through},
{&VertexDecoder::Step_PosS16Through, &VertexDecoderJitCache::Jit_PosS16Through},
{&VertexDecoder::Step_PosFloatThrough, &VertexDecoderJitCache::Jit_PosFloat},
{&VertexDecoder::Step_PosS8, &VertexDecoderJitCache::Jit_PosS8},
{&VertexDecoder::Step_PosS16, &VertexDecoderJitCache::Jit_PosS16},
{&VertexDecoder::Step_PosFloat, &VertexDecoderJitCache::Jit_PosFloat},
{&VertexDecoder::Step_PosS8Skin, &VertexDecoderJitCache::Jit_PosS8Skin},
{&VertexDecoder::Step_PosS16Skin, &VertexDecoderJitCache::Jit_PosS16Skin},
{&VertexDecoder::Step_PosFloatSkin, &VertexDecoderJitCache::Jit_PosFloatSkin},
{&VertexDecoder::Step_NormalS8Morph, &VertexDecoderJitCache::Jit_NormalS8Morph},
{&VertexDecoder::Step_NormalS16Morph, &VertexDecoderJitCache::Jit_NormalS16Morph},
{&VertexDecoder::Step_NormalFloatMorph, &VertexDecoderJitCache::Jit_NormalFloatMorph},
{&VertexDecoder::Step_PosS8Morph, &VertexDecoderJitCache::Jit_PosS8Morph},
{&VertexDecoder::Step_PosS16Morph, &VertexDecoderJitCache::Jit_PosS16Morph},
{&VertexDecoder::Step_PosFloatMorph, &VertexDecoderJitCache::Jit_PosFloatMorph},
{&VertexDecoder::Step_Color8888Morph, &VertexDecoderJitCache::Jit_Color8888Morph},
{&VertexDecoder::Step_Color4444Morph, &VertexDecoderJitCache::Jit_Color4444Morph},
{&VertexDecoder::Step_Color565Morph, &VertexDecoderJitCache::Jit_Color565Morph},
{&VertexDecoder::Step_Color5551Morph, &VertexDecoderJitCache::Jit_Color5551Morph},
};
JittedVertexDecoder VertexDecoderJitCache::Compile(const VertexDecoder &dec) {
dec_ = &dec;
const u8 *start = AlignCode16();
bool prescaleStep = false;
bool skinning = false;
return (JittedVertexDecoder)start;
}
void VertexDecoderJitCache::Jit_WeightsU8() {
}
void VertexDecoderJitCache::Jit_WeightsU16() {
}
void VertexDecoderJitCache::Jit_WeightsFloat() {
}
void VertexDecoderJitCache::Jit_ApplyWeights() {
}
void VertexDecoderJitCache::Jit_WeightsU8Skin() {
}
void VertexDecoderJitCache::Jit_WeightsU16Skin() {
}
void VertexDecoderJitCache::Jit_WeightsFloatSkin() {
}
void VertexDecoderJitCache::Jit_TcU8() {
}
void VertexDecoderJitCache::Jit_TcU16() {
}
void VertexDecoderJitCache::Jit_TcFloat() {
}
void VertexDecoderJitCache::Jit_TcU16Through() {
}
void VertexDecoderJitCache::Jit_TcFloatThrough() {
}
void VertexDecoderJitCache::Jit_TcU16Double() {
}
void VertexDecoderJitCache::Jit_TcU16ThroughDouble() {
}
void VertexDecoderJitCache::Jit_TcU8Prescale() {
}
void VertexDecoderJitCache::Jit_TcU16Prescale() {
}
void VertexDecoderJitCache::Jit_TcFloatPrescale() {
}
void VertexDecoderJitCache::Jit_Color8888() {
}
void VertexDecoderJitCache::Jit_Color4444() {
}
void VertexDecoderJitCache::Jit_Color565() {
}
void VertexDecoderJitCache::Jit_Color5551() {
}
void VertexDecoderJitCache::Jit_Color8888Morph() {
}
void VertexDecoderJitCache::Jit_Color4444Morph() {
}
void VertexDecoderJitCache::Jit_Color565Morph() {
}
void VertexDecoderJitCache::Jit_Color5551Morph() {
}
void VertexDecoderJitCache::Jit_WriteMorphColor(int outOff, bool checkAlpha) {
}
void VertexDecoderJitCache::Jit_NormalS8() {
}
void VertexDecoderJitCache::Jit_NormalS16() {
}
void VertexDecoderJitCache::Jit_NormalFloat() {
}
void VertexDecoderJitCache::Jit_PosS8Through() {
}
void VertexDecoderJitCache::Jit_PosS16Through() {
}
void VertexDecoderJitCache::Jit_PosS8() {
}
void VertexDecoderJitCache::Jit_PosS16() {
}
// Just copy 12 bytes.
void VertexDecoderJitCache::Jit_PosFloat() {
}
void VertexDecoderJitCache::Jit_NormalS8Skin() {
}
void VertexDecoderJitCache::Jit_NormalS16Skin() {
}
void VertexDecoderJitCache::Jit_NormalFloatSkin() {
}
void VertexDecoderJitCache::Jit_WriteMatrixMul(int outOff, bool pos) {
}
void VertexDecoderJitCache::Jit_PosS8Skin() {
}
void VertexDecoderJitCache::Jit_PosS16Skin() {
}
void VertexDecoderJitCache::Jit_PosFloatSkin() {
}
void VertexDecoderJitCache::Jit_AnyS8ToFloat(int srcoff) {
}
void VertexDecoderJitCache::Jit_AnyS16ToFloat(int srcoff) {
}
void VertexDecoderJitCache::Jit_AnyS8Morph(int srcoff, int dstoff) {
}
void VertexDecoderJitCache::Jit_AnyS16Morph(int srcoff, int dstoff) {
}
void VertexDecoderJitCache::Jit_AnyFloatMorph(int srcoff, int dstoff) {
}
void VertexDecoderJitCache::Jit_PosS8Morph() {
Jit_AnyS8Morph(dec_->posoff, dec_->decFmt.posoff);
}
void VertexDecoderJitCache::Jit_PosS16Morph() {
Jit_AnyS16Morph(dec_->posoff, dec_->decFmt.posoff);
}
void VertexDecoderJitCache::Jit_PosFloatMorph() {
Jit_AnyFloatMorph(dec_->posoff, dec_->decFmt.posoff);
}
void VertexDecoderJitCache::Jit_NormalS8Morph() {
Jit_AnyS8Morph(dec_->nrmoff, dec_->decFmt.nrmoff);
}
void VertexDecoderJitCache::Jit_NormalS16Morph() {
Jit_AnyS16Morph(dec_->nrmoff, dec_->decFmt.nrmoff);
}
void VertexDecoderJitCache::Jit_NormalFloatMorph() {
Jit_AnyFloatMorph(dec_->nrmoff, dec_->decFmt.nrmoff);
}
bool VertexDecoderJitCache::CompileStep(const VertexDecoder &dec, int step) {
return false;
}

5
Qt/Common.pro
View File

@ -10,7 +10,7 @@ arm {
SOURCES += $$P/Common/ArmCPUDetect.cpp \
$$P/Common/ArmThunk.cpp
}
i86 {
else:i86 {
SOURCES += $$P/Common/ABI.cpp \
$$P/Common/CPUDetect.cpp \
$$P/Common/Thunk.cpp \
@ -21,6 +21,9 @@ i86 {
$$P/Common/x64Analyzer.h \
$$P/Common/x64Emitter.h
}
else {
SOURCES += $$P/Common/FakeCPUDetect.cpp
}
SOURCES += $$P/Common/ArmEmitter.cpp
HEADERS += $$P/Common/ArmEmitter.h \
$$P/Common/CPUDetect.h

3
Qt/GPU.pro
View File

@ -57,7 +57,8 @@ SOURCES += $$P/GPU/GeDisasm.cpp \ # GPU
armv7: SOURCES += $$P/GPU/Common/TextureDecoderNEON.cpp
arm: SOURCES += $$P/GPU/Common/VertexDecoderArm.cpp
i86: SOURCES += $$P/GPU/Common/VertexDecoderX86.cpp
else:i86: SOURCES += $$P/GPU/Common/VertexDecoderX86.cpp
else: SOURCES += $$P/GPU/Common/VertexDecoderFake.cpp
HEADERS += $$P/GPU/GLES/*.h \
$$P/GPU/Software/*.h \

2
Qt/Settings.pri
View File

@ -58,10 +58,10 @@ contains(QT_CONFIG, opengles.) {
DEFINES += USING_GLES2
# How else do we know if the environment prefers windows?
!equals(PLATFORM_NAME, "linux")|android|maemo {
DEFINES += MOBILE_DEVICE
CONFIG += mobile_platform
}
}
mobile_platform: DEFINES += MOBILE_DEVICE
# Handle flags for both C and C++
QMAKE_CFLAGS += $$QMAKE_ALLFLAGS

2
ffmpeg

@ -1 +1 @@
Subproject commit bc6302be00fdb71ac5e24b40c5e826d4e8a9a2ac
Subproject commit 0bacf0993fe6a74370a2701695bfc2cafec5f214