diff options
Diffstat (limited to 'o3d/converter')
21 files changed, 2143 insertions, 0 deletions
diff --git a/o3d/converter/README.converter b/o3d/converter/README.converter new file mode 100644 index 0000000..77fdd0a --- /dev/null +++ b/o3d/converter/README.converter @@ -0,0 +1,51 @@ +The converter is a command line utility that will convert from COLLADA +to the form that the sample JavaScript scene loader (in +samples/o3djs/serialization.js) can read. + +It is able to read COLLADA files as either DAE text files (and +associated asset files in subdirectories), or as part of a ZIP archive +(or KMZ file). It outputs a gzip-compressed tar archive (.tgz) which +contains a JSON file and any associated assets (textures, shaders, +etc.) from the source COLLADA model. By default we don't use the .tgz +extension, as it can cause problems with some webservers; we put .o3dtgz on +instead. + +In order to run the converter on Windows, you need the DirectX SDK installed. +Installing it requires administrator privileges. You can get it here: +http://msdn.microsoft.com/en-us/library/bb219737(VS.85).aspx. + +The command line arguments are as follows: + +Usage: o3dConverter.exe [--base-path=<path>] + [--up-axis=x,y,z] + [--no-condition] + [--pretty-print] + <infile.dae> [ <outfile> ] + +--base-path=<path>: This specifies the path elements to remove from + the beginning of the filenames placed into the + .o3dtgz file (to avoid including sensitive paths in + the .o3dtgz file). + +--up-axis=x,y,z: This specifies the up-axis for the resulting model, + if you wish it to be different from the axis in the + COLLADA file. + +--pretty-print: This simply formats the JSON file in the resulting + .o3dtgz file to be human readable, instead of compacted + into one line. + +--no-condition: This will prevent conditioning of the shaders from + COLLADA form to the form expected by O3D. [This is + useful only for pre-release data conditioned before + the converter existed.] + +<infile.dae|infile.zip|infile.kmz>: This is the input file in one of + ZIP, KMZ, or DAE formats. The + DAE format expects to find assets + relative to the .dae file. + +<outfile>: An optional argument giving the name of the + gzip-compressed tar archive output file. By default + this has the same basename as the input file, and has the extension + .o3dtgz. diff --git a/o3d/converter/README.verifier b/o3d/converter/README.verifier new file mode 100644 index 0000000..af776bf --- /dev/null +++ b/o3d/converter/README.verifier @@ -0,0 +1,32 @@ +The verifier is a command line utility that will verify shader files. + +This utility is used to verify that a shader will compile when given +to O3D to render. On Windows, it will test-compile the given shader +with both Cg and HLSL compilers. On Mac and Linux platforms, it will +only compile using Cg (since DirectX isn't available on those +platforms). This will help users on Windows verify that their shaders +will run when displayed on Mac or Linux platforms, and will help +everyone verify that their shaders compile. + +If an output file is specified, it can be used to convert shaders to a +form that can be used directly in O3D. It strips out unneeded blocks +(like the technique/pass blocks) and replaces them with the O3D +comments which describe the shader entry points. + +The command line arguments are as follows: + +Usage: o3dVerifier.exe [--no-condition] <infile.fx> [ <outfile.fx> ] + +--no-condition: This will prevent conditioning of the shaders into the + form expected by O3D. Specifying this causes the + verifier to ignore any output file specified (since + that would just be copying the file, and not doing any + conditioning). This option is useful only for + verifying pre-conditioned shaders. + +<infile.fx>: This is the input filename of the shader to be validated. + +<outfile.fx>: An optional argument giving the name of the desired + output location of the conditioned shader file in the + form expected by O3D. If you don't specify this, then + no output is created. diff --git a/o3d/converter/build.scons b/o3d/converter/build.scons new file mode 100644 index 0000000..50c7785 --- /dev/null +++ b/o3d/converter/build.scons @@ -0,0 +1,174 @@ +# Copyright 2009, Google Inc. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +Import('env') + +env.Append( + LIBPATH = [ + '$NACL_LIB_DIR', + '$ANTLRLIBC_DIR/lib', + '$OBJ_ROOT/compiler/technique', + '$OBJ_ROOT/compiler/antlr', + '$CG_DIR/lib', + ], + LIBS = [ + 'o3dConvert', + 'o3dCore', + 'o3dArchive', + 'o3dImport', + 'o3dImportConditioner', + 'o3dCorePlatform', + 'o3dSerializer', + 'o3dUtils', + 'o3d_base', + 'FColladaU', + 'technique', + 'antlr3c', + 'google_nacl_imc', + 'skia', + ] + env['ICU_LIBS'], +) + +# add renderer specific libraries and includes to the linker environment +env.Append(CPPPATH = env['RENDERER_INCLUDE_PATH'], + LIBPATH = env['RENDERER_LIB_PATH'], + LIBS = env['RENDERER_LIBS']) + +if env.Bit('windows'): + env.Append( + CCFLAGS=['/Wp64', '/D_CRT_SECURE_NO_WARNINGS'], + LINKFLAGS=['/SUBSYSTEM:CONSOLE'], + LIBS = [ + 'cg', + 'cgGL', + 'd3dx9', + 'ole32', + ], + ) + +if env.Bit('mac'): + env.Append( + LINKFLAGS = ['-F$CG_DIR'], + FRAMEWORKS = [ + 'ApplicationServices', + 'Cg', + 'Foundation', + 'OpenGL', + ], + ) + +inputs = [ + 'cross/converter.cc', + 'cross/renderer_stub.cc', + 'cross/buffer_stub.cc', + 'cross/texture_stub.cc', + ] + +# Create converter library. +lib = env.ComponentLibrary('o3dConvert', inputs) + +# Create a target executable program called 'o3dConverter' +if env.Bit('mac'): + exe = env.ComponentProgram('o3dConverter', + ['mac/converter_main.mm', + 'cross/converter_main.cc', + ]) + # Fix executable to look for Cg.framework in the appropriate place. + exe_fix = env.Command('$ARTIFACTS_DIR/converter/fixed_exe.stamp', + [exe], [ + '/usr/bin/install_name_tool' + ' -change ' + '@executable_path/../Library/Frameworks/Cg.framework/Cg ' + '@executable_path/Frameworks/Cg.framework/Cg ' + "$SOURCE", + 'touch $TARGET', + ]) + # Copy the resulting executable to the Artifacts directory. + exe_install = env.Replicate('$ARTIFACTS_DIR/converter', [exe]) + env.Depends(exe_install, exe_fix) +else: + exe = env.ComponentProgram('o3dConverter', ['cross/converter_main.cc']) + # Copy the resulting executable to the Artifacts directory. + exe_install = env.Replicate('$ARTIFACTS_DIR', [exe]) + +# Create a target executable program called 'o3dVerifier' +if env.Bit('mac'): + verifier_exe = env.ComponentProgram('o3dVerifier', + ['mac/converter_main.mm', + 'cross/verifier_main.cc', + ]) + # Copy the resulting executable to the Artifacts directory. + verifier_exe_install = env.Replicate('$ARTIFACTS_DIR/converter', + [verifier_exe]) + verifier_exe_fix = env.Command('$ARTIFACTS_DIR/converter/verifier_exe.stamp', + [verifier_exe_install], [ + '/usr/bin/install_name_tool' + ' -change ' + '@executable_path/../Library/Frameworks/Cg.framework/Cg ' + '@executable_path/Frameworks/Cg.framework/Cg ' + "$SOURCE", + 'touch $TARGET', + ]) +else: + verifier_exe = env.ComponentProgram('o3dVerifier', ['cross/verifier_main.cc']) + # Copy the resulting executable to the Artifacts directory. + verifier_exe_install = env.Replicate('$ARTIFACTS_DIR', [verifier_exe]) + +# Put the Cg DLL's, cgc and the d3dx9 DLL there as well. +if env.Bit('windows'): + env.Requires(exe_install, env.Replicate( + '$ARTIFACTS_DIR', [ + '$CG_DIR/bin/cgc.exe', + '$CG_DIR/bin/cg.dll', + '$CG_DIR/bin/cgGL.dll', + ])) + +if env.Bit('mac'): + env.Requires( + exe_install, + env.Command(env.Dir('$ARTIFACTS_DIR/converter/Frameworks'), + env.Dir("$CG_DIR/Cg.framework"), + [ # Copy in a Cg framework for the converter to use. + 'ditto --arch i386 "$CG_DIR/Cg.framework" ' + '"$ARTIFACTS_DIR/converter/Frameworks/Cg.framework"', + ])) + env.Requires(exe_install, env.Replicate( + '$ARTIFACTS_DIR/converter', [ + '$CG_DIR/bin/cgc', + ])) + +if env.Bit('linux'): + env.Requires(exe_install, env.Replicate( + '$ARTIFACTS_DIR', [ + '$CG_DIR/bin/cgc', + '$CG_DIR/lib/libCg.so', + '$CG_DIR/lib/libCgGL.so', + '$GLEW_DIR/lib/libGLEW.so.1.5', + ])) diff --git a/o3d/converter/cross/buffer_stub.cc b/o3d/converter/cross/buffer_stub.cc new file mode 100644 index 0000000..d400ff2 --- /dev/null +++ b/o3d/converter/cross/buffer_stub.cc @@ -0,0 +1,87 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the definition of the VertexBufferStub and +// IndexBufferStub classes. + +#include "converter/cross/buffer_stub.h" + +namespace o3d { + +bool VertexBufferStub::ConcreteAllocate(size_t size_in_bytes) { + buffer_.reset(new int8[size_in_bytes]); + return true; +} + +void VertexBufferStub::ConcreteFree() { + buffer_.reset(); +} + +bool VertexBufferStub::ConcreteLock(AccessMode access_mode, + void** buffer_data) { + *buffer_data = buffer_.get(); + DCHECK(locked_ == false); + locked_ = true; + return (buffer_.get() != NULL); +} + +bool VertexBufferStub::ConcreteUnlock() { + bool status = locked_; + DCHECK(locked_ == true); + locked_ = false; + return status; +} + +bool IndexBufferStub::ConcreteAllocate(size_t size_in_bytes) { + buffer_.reset(new int8[size_in_bytes]); + return true; +} + +void IndexBufferStub::ConcreteFree() { + buffer_.reset(); +} + +bool IndexBufferStub::ConcreteLock(AccessMode access_mode, void** buffer_data) { + *buffer_data = buffer_.get(); + DCHECK(locked_ == false); + locked_ = true; + return (buffer_.get() != NULL); +} + +bool IndexBufferStub::ConcreteUnlock() { + bool status = locked_; + DCHECK(locked_ == true); + locked_ = false; + return status; +} + +} // end namespace o3d diff --git a/o3d/converter/cross/buffer_stub.h b/o3d/converter/cross/buffer_stub.h new file mode 100644 index 0000000..26c0aad --- /dev/null +++ b/o3d/converter/cross/buffer_stub.h @@ -0,0 +1,112 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the declaration of the platform specific +// VertexBufferStub and IndexBufferStub objects used by O3D + +#ifndef O3D_CONVERTER_CROSS_BUFFER_STUB_H_ +#define O3D_CONVERTER_CROSS_BUFFER_STUB_H_ + +#include "base/basictypes.h" +#include "base/scoped_ptr.h" +#include "core/cross/buffer.h" + +namespace o3d { + +// VertexBufferStub is a wrapper around an Stub Vertex Buffer Object (VBO). +// The buffer starts out empty. Calling Allocate() will reserve video memory +// for the buffer. Buffer contents are are updated by calling Lock() to get a +// pointer to the memory allocated for the buffer, updating that data in place +// and calling Unlock() to notify Stub that the edits are done. + +class VertexBufferStub : public VertexBuffer { + public: + explicit VertexBufferStub(ServiceLocator* service_locator) + : VertexBuffer(service_locator), locked_(false) {} + ~VertexBufferStub() {} + + protected: + // Creates a Stub vertex buffer object of the specified size. + virtual bool ConcreteAllocate(size_t size_in_bytes); + + // Frees the buffer. + virtual void ConcreteFree(); + + // Returns a pointer to the current contents of the buffer. A matching + // call to Unlock is necessary to update the contents of the buffer. + virtual bool ConcreteLock(AccessMode access_mode, void** buffer_data); + + // Notifies Stub that the buffer data has been updated. Unlock is only + // valid if it follows a Lock operation. + virtual bool ConcreteUnlock(); + private: + scoped_array<int8> buffer_; + bool locked_; + + DISALLOW_COPY_AND_ASSIGN(VertexBufferStub); +}; + +// IndexBufferStub is a wrapper around a Stub Index Buffer Object. +// The buffer starts out empty. A call to Allocate() will create a stub +// index buffer of the requested size. Updates the to the contents of the +// buffer are done via the Lock/Unlock calls. +class IndexBufferStub : public IndexBuffer { + public: + explicit IndexBufferStub(ServiceLocator* service_locator) + : IndexBuffer(service_locator), locked_(false) {} + ~IndexBufferStub() {} + + protected: + // Creates a OpenGL index buffer of the specified size. + virtual bool ConcreteAllocate(size_t size_in_bytes); + + // Frees the buffer. + virtual void ConcreteFree(); + + // Returns a pointer to the current contents of the buffer. After calling + // Lock, the contents of the buffer can be updated in place. + virtual bool ConcreteLock(AccessMode access_mode, void** buffer_data); + + // Notifies OpenGL that the buffer data has been updated. Unlock is only + // valid if it follows a Lock operation. + virtual bool ConcreteUnlock(); + private: + scoped_array<int8> buffer_; + bool locked_; + + DISALLOW_COPY_AND_ASSIGN(IndexBufferStub); +}; + +} // namespace o3d + + +#endif // O3D_CONVERTER_CROSS_BUFFER_STUB_H_ diff --git a/o3d/converter/cross/converter.cc b/o3d/converter/cross/converter.cc new file mode 100644 index 0000000..511b69f --- /dev/null +++ b/o3d/converter/cross/converter.cc @@ -0,0 +1,312 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the logic for converting the scene graph to a +// JSON-encoded file that is stored in a zip archive. +#include "converter/cross/converter.h" + +#include "base/file_path.h" +#include "base/file_util.h" +#include "base/scoped_ptr.h" +#include "core/cross/class_manager.h" +#include "core/cross/client.h" +#include "core/cross/effect.h" +#include "core/cross/error.h" +#include "core/cross/features.h" +#include "core/cross/object_manager.h" +#include "core/cross/pack.h" +#include "core/cross/renderer.h" +#include "core/cross/service_locator.h" +#include "core/cross/transform.h" +#include "core/cross/tree_traversal.h" +#include "core/cross/types.h" +#include "import/cross/collada.h" +#include "import/cross/collada_conditioner.h" +#include "import/cross/file_output_stream_processor.h" +#include "import/cross/targz_generator.h" +#include "import/cross/archive_request.h" +#include "serializer/cross/serializer.h" +#include "utils/cross/file_path_utils.h" +#include "utils/cross/json_writer.h" +#include "utils/cross/string_writer.h" +#include "utils/cross/temporary_file.h" + +namespace o3d { + +namespace { +void AddBinaryElements(const Collada& collada, + TarGzGenerator* archive_generator) { + std::vector<FilePath> paths = collada.GetOriginalDataFilenames(); + for (std::vector<FilePath>::const_iterator iter = paths.begin(); + iter != paths.end(); + ++iter) { + const std::string& data = collada.GetOriginalData(*iter); + + archive_generator->AddFile(FilePathToUTF8(*iter), data.size()); + archive_generator->AddFileBytes( + reinterpret_cast<const uint8*>(data.c_str()), + data.length()); + } +} +} // end anonymous namespace + +namespace converter { +// Loads the Collada input file and writes it to the zipped JSON output file. +bool Convert(const FilePath& in_filename, + const FilePath& out_filename, + const Options& options, + String *error_messages) { + // Create a service locator and renderer. + ServiceLocator service_locator; + EvaluationCounter evaluation_counter(&service_locator); + ClassManager class_manager(&service_locator); + ObjectManager object_manager(&service_locator); + Profiler profiler(&service_locator); + ErrorStatus error_status(&service_locator); + Features features(&service_locator); + + features.Init("MaxCapabilities"); + + // Collect error messages. + ErrorCollector error_collector(&service_locator); + + scoped_ptr<Renderer> renderer( + Renderer::CreateDefaultRenderer(&service_locator)); + renderer->InitCommon(); + + Pack::Ref pack(object_manager.CreatePack()); + Transform* root = pack->Create<Transform>(); + root->set_name(String(Serializer::ROOT_PREFIX) + String("root")); + + // Setup a ParamFloat to be the source to all animations in this file. + ParamObject* param_object = pack->Create<ParamObject>(); + // This is some arbitrary name + param_object->set_name(O3D_STRING_CONSTANT("animSourceOwner")); + ParamFloat* param_float = param_object->CreateParam<ParamFloat>("animSource"); + + Collada::Options collada_options; + collada_options.condition_document = options.condition; + collada_options.keep_original_data = true; + collada_options.base_path = options.base_path; + collada_options.up_axis = options.up_axis; + Collada collada(pack.Get(), collada_options); + if (!collada.ImportFile(in_filename, root, param_float)) { + if (error_messages) { + *error_messages += error_collector.errors(); + } + return false; + } + + // Remove the animation param_object (and indirectly the param_float) + // if there is no animation. + if (param_float->output_connections().empty()) { + pack->RemoveObject(param_object); + } + + // Attempt to open the output file. + FILE* out_file = file_util::OpenFile(out_filename, "wb"); + if (out_file == NULL) { + O3D_ERROR(&service_locator) << "Could not open output file \"" + << FilePathToUTF8(out_filename).c_str() + << "\""; + if (error_messages) { + *error_messages += error_collector.errors(); + } + return false; + } + + // Create an archive file and serialize the JSON scene graph and assets to it. + FileOutputStreamProcessor stream_processor(out_file); + TarGzGenerator archive_generator(&stream_processor); + + archive_generator.AddFile(ArchiveRequest::O3D_MARKER, + ArchiveRequest::O3D_MARKER_CONTENT_LENGTH); + archive_generator.AddFileBytes( + reinterpret_cast<const uint8*>(ArchiveRequest::O3D_MARKER_CONTENT), + ArchiveRequest::O3D_MARKER_CONTENT_LENGTH); + + // Serialize the created O3D scene graph to JSON. + StringWriter out_writer(StringWriter::LF); + JsonWriter json_writer(&out_writer, 2); + if (!options.pretty_print) { + json_writer.BeginCompacting(); + } + Serializer serializer(&service_locator, &json_writer, &archive_generator); + serializer.SerializePack(pack.Get()); + json_writer.Close(); + out_writer.Close(); + if (!options.pretty_print) { + json_writer.EndCompacting(); + } + + String json = out_writer.ToString(); + + archive_generator.AddFile("scene.json", json.length()); + archive_generator.AddFileBytes(reinterpret_cast<const uint8*>(json.c_str()), + json.length()); + + // Now add original data (e.g. compressed textures) collected during + // the loading process. + AddBinaryElements(collada, &archive_generator); + + archive_generator.Finalize(); + + file_util::CloseFile(out_file); + + pack->Destroy(); + if (error_messages) { + *error_messages = error_collector.errors(); + } + return true; +} + +// Loads the input shader file and validates it. +bool Verify(const FilePath& in_filename, + const FilePath& out_filename, + const Options& options, + String* error_messages) { + FilePath source_filename(in_filename); + // Create a service locator and renderer. + ServiceLocator service_locator; + EvaluationCounter evaluation_counter(&service_locator); + ClassManager class_manager(&service_locator); + ObjectManager object_manager(&service_locator); + Profiler profiler(&service_locator); + ErrorStatus error_status(&service_locator); + + // Collect error messages. + ErrorCollector error_collector(&service_locator); + + scoped_ptr<Renderer> renderer( + Renderer::CreateDefaultRenderer(&service_locator)); + renderer->InitCommon(); + + Pack::Ref pack(object_manager.CreatePack()); + Transform* root = pack->Create<Transform>(); + root->set_name(O3D_STRING_CONSTANT("root")); + + Collada::Options collada_options; + collada_options.condition_document = options.condition; + collada_options.keep_original_data = false; + Collada collada(pack.Get(), collada_options); + + ColladaConditioner conditioner(&service_locator); + String vertex_shader_entry_point; + String fragment_shader_entry_point; + TemporaryFile temp_file; + if (options.condition) { + if (!TemporaryFile::Create(&temp_file)) { + O3D_ERROR(&service_locator) << "Could not create temporary file"; + if (error_messages) { + *error_messages = error_collector.errors(); + } + return false; + } + SamplerStateList state_list; + if (!conditioner.RewriteShaderFile(NULL, + in_filename, + temp_file.path(), + &state_list, + &vertex_shader_entry_point, + &fragment_shader_entry_point)) { + O3D_ERROR(&service_locator) << "Could not rewrite shader file"; + if (error_messages) { + *error_messages = error_collector.errors(); + } + return false; + } + source_filename = temp_file.path(); + } else { + source_filename = in_filename; + } + + std::string shader_source_in; + // Load file into memory + if (!file_util::ReadFileToString(source_filename, &shader_source_in)) { + O3D_ERROR(&service_locator) << "Could not read shader file " + << FilePathToUTF8(source_filename).c_str(); + if (error_messages) { + *error_messages = error_collector.errors(); + } + return false; + } + + Effect::MatrixLoadOrder matrix_load_order; + scoped_ptr<Effect> effect(pack->Create<Effect>()); + if (!effect->ValidateFX(shader_source_in, + &vertex_shader_entry_point, + &fragment_shader_entry_point, + &matrix_load_order)) { + O3D_ERROR(&service_locator) << "Could not validate shader file"; + if (error_messages) { + *error_messages = error_collector.errors(); + } + return false; + } + + if (!conditioner.CompileHLSL(shader_source_in, + vertex_shader_entry_point, + fragment_shader_entry_point)) { + O3D_ERROR(&service_locator) << "Could not HLSL compile shader file"; + if (error_messages) { + *error_messages = error_collector.errors(); + } + return false; + } + + if (!conditioner.CompileCg(in_filename, + shader_source_in, + vertex_shader_entry_point, + fragment_shader_entry_point)) { + O3D_ERROR(&service_locator) << "Could not Cg compile shader file"; + if (error_messages) { + *error_messages = error_collector.errors(); + } + return false; + } + + // If we've validated the file, then we write out the conditioned + // shader to the given output file, if there is one. + if (options.condition && !out_filename.empty()) { + if (file_util::WriteFile(out_filename, shader_source_in.c_str(), + shader_source_in.size()) == -1) { + O3D_ERROR(&service_locator) << "Warning: Could not write to output file '" + << FilePathToUTF8(in_filename).c_str() << "'"; + } + } + if (error_messages) { + *error_messages = error_collector.errors(); + } + return true; +} +} // end namespace converter +} // end namespace o3d diff --git a/o3d/converter/cross/converter.h b/o3d/converter/cross/converter.h new file mode 100644 index 0000000..1524493 --- /dev/null +++ b/o3d/converter/cross/converter.h @@ -0,0 +1,92 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the declarations for the functions in the +// O3D converter namespace. These functions do most of the actual +// work of conditioning and packagaging a JSON file for use in +// O3D. + +#ifndef O3D_CONVERTER_CROSS_CONVERTER_H_ +#define O3D_CONVERTER_CROSS_CONVERTER_H_ + +#include "base/file_path.h" +#include "core/cross/types.h" + +namespace o3d { +namespace converter { + +// Options struct for passing to the converter. +struct Options { + Options() + : base_path(FilePath::kCurrentDirectory), + condition(true), + up_axis(0, 0, 0), + pretty_print(false) {} + + // The path to the "base" of the model path, from which all paths + // are made relative. Defaults to the current directory. + FilePath base_path; + + // Indicates if the converter should condition the input shaders or + // not. + bool condition; + + // The up axis of the output. The input will be converted to a new coordinate + // system if it indicates a different up axis. Zero means no conversion. + Vector3 up_axis; + + // This indicates whether or not the serialized JSON code should be + // pretty-printed (formatted with spaces and newlines) or just + // emitted as one huge one-line string. Defaults to false. + bool pretty_print; +}; + +// Converts the given file for use in O3D. This is done by +// loading the input file, traversing the scene graph and serializing +// what is found there. +bool Convert(const FilePath& in_filename, + const FilePath& out_filename, + const Options& options, + String* error_messages); + +// Verifies the given shader file as "valid". Returns true if input +// shader file contains valid code (code that can be compiled +// successfully). +bool Verify(const FilePath& in_filename, + const FilePath& out_filename, + const Options& options, + String* error_messages); + +} // namespace converter +} // namespace o3d + +#endif // O3D_CONVERTER_CROSS_CONVERTER_H_ diff --git a/o3d/converter/cross/converter_main.cc b/o3d/converter/cross/converter_main.cc new file mode 100644 index 0000000..85cc594 --- /dev/null +++ b/o3d/converter/cross/converter_main.cc @@ -0,0 +1,126 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the main routine for the converter that writes +// out a scene graph as a JSON file. + +#include <string> +#include <iostream> +#include <vector> + +#include "base/at_exit.h" +#include "base/command_line.h" +#include "base/file_path.h" +#include "converter/cross/converter.h" +#include "utils/cross/file_path_utils.h" + +using std::string; +using std::wstring; + +#if defined(OS_WIN) +int wmain(int argc, wchar_t **argv) { + // On Windows, CommandLine::Init ignores its arguments and uses + // GetCommandLineW. + CommandLine::Init(0, NULL); +#endif +#if defined(OS_LINUX) +int main(int argc, char **argv) { + CommandLine::Init(argc, argv); +#endif +#if defined(OS_MACOSX) +// The "real" main on Mac is in mac/converter_main.mm, so we can get +// memory pool initialization for Cocoa. +int CrossMain(int argc, char**argv) { + CommandLine::Init(argc, argv); +#endif + // Create an at_exit_manager so that base singletons will get + // deleted properly. + base::AtExitManager at_exit_manager; + const CommandLine* command_line = CommandLine::ForCurrentProcess(); + + FilePath in_filename, out_filename; + + std::vector<std::wstring> values = command_line->GetLooseValues(); + if (values.size() == 1) { + // If we're only given one argument, then construct the output + // filename by substituting the extension on the filename (if any) + // with .o3dtgz. + in_filename = o3d::WideToFilePath(values[0]); + out_filename = in_filename.ReplaceExtension(FILE_PATH_LITERAL(".o3dtgz")); + } else if (values.size()== 2) { + in_filename = o3d::WideToFilePath(values[0]); + out_filename = o3d::WideToFilePath(values[1]); + } else { + std::cerr << "Usage: " << argv[0] + << " [--no-condition] [--base-path=<path>] [--up-axis=x,y,z]" + << " [--pretty-print] <infile.dae> [ <outfile> ]\n"; + return EXIT_FAILURE; + } + + o3d::converter::Options options; + options.condition = !command_line->HasSwitch(L"no-condition"); + options.pretty_print = command_line->HasSwitch(L"pretty-print"); + if (command_line->HasSwitch(L"base-path")) { + options.base_path = o3d::WideToFilePath( + command_line->GetSwitchValue(L"base-path")); + } + if (command_line->HasSwitch(L"up-axis")) { + wstring up_axis_string = command_line->GetSwitchValue(L"up-axis"); + int x, y, z; + if (swscanf(up_axis_string.c_str(), L"%d,%d,%d", &x, &y, &z) != 3) { + std::cerr << "Invalid --up-axis value. Should be --up-axis=x,y,z\n"; + return EXIT_FAILURE; + } + options.up_axis = o3d::Vector3(static_cast<float>(x), + static_cast<float>(y), + static_cast<float>(z)); + } + + o3d::String error_messages; + bool result = o3d::converter::Convert(in_filename, + out_filename, + options, + &error_messages); + if (result) { + std::cerr << "Converted '" << o3d::FilePathToUTF8(in_filename).c_str() + << "' to '" << o3d::FilePathToUTF8(out_filename).c_str() + << "'." << std::endl; + return EXIT_SUCCESS; + } else { + std::cerr << error_messages.c_str() << std::endl; + std::cerr << "FAILED to convert '" + << o3d::FilePathToUTF8(in_filename).c_str() + << "' to '" << o3d::FilePathToUTF8(out_filename).c_str() + << "'." << std::endl; + return EXIT_FAILURE; + } +} diff --git a/o3d/converter/cross/draw_element_stub.h b/o3d/converter/cross/draw_element_stub.h new file mode 100644 index 0000000..6d92ebc --- /dev/null +++ b/o3d/converter/cross/draw_element_stub.h @@ -0,0 +1,58 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the declaration of the DrawElementGL class. + +#ifndef O3D_CONVERTER_CROSS_DRAW_ELEMENT_STUB_H_ +#define O3D_CONVERTER_CROSS_DRAW_ELEMENT_STUB_H_ + +#include "core/cross/draw_element.h" + +namespace o3d { + +class ServiceLocator; + +// DrawElementStub is the Stub implementation of the DrawElement. It +// provides a place for the renderer to store platform specific cache +// information. +class DrawElementStub : public DrawElement { + public: + explicit DrawElementStub(ServiceLocator* service_locator) + : DrawElement(service_locator) {} + ~DrawElementStub() {} + + private: + DISALLOW_COPY_AND_ASSIGN(DrawElementStub); +}; +} // o3d + +#endif // O3D_CONVERTER_CROSS_DRAW_ELEMENT_STUB_H_ diff --git a/o3d/converter/cross/effect_stub.h b/o3d/converter/cross/effect_stub.h new file mode 100644 index 0000000..7a54a9b --- /dev/null +++ b/o3d/converter/cross/effect_stub.h @@ -0,0 +1,73 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the declaration of the EffectGL class. + +#ifndef O3D_CONVERTER_CROSS_EFFECT_STUB_H_ +#define O3D_CONVERTER_CROSS_EFFECT_STUB_H_ + +#include "core/cross/effect.h" + +namespace o3d { + +class ServiceLocator; + +// EffectStub is an implementation of the Effect object for the +// converter. It provides the API for setting the vertex and fragment +// shaders for the Effect using the Cg Runtime. +class EffectStub : public Effect { + public: + explicit EffectStub(ServiceLocator* service_locator) + : Effect(service_locator) {} + virtual ~EffectStub() {} + + // Reads the vertex and fragment shaders from string in the FX format. + // It returns true if the shaders were successfully compiled. + virtual bool LoadFromFXString(const String& effect) { return true; } + + // Gets info about the parameters this effect needs. + // Overriden from Effect. + virtual void GetParameterInfo(EffectParameterInfoArray* info_array) {} + + // Gets info about the varying parameters this effects vertex shader needs. + // Parameters: + // info_array: EffectParameterInfoArray to receive info. + virtual void GetStreamInfo( + EffectStreamInfoArray* info_array) { + } + + private: + DISALLOW_COPY_AND_ASSIGN(EffectStub); +}; +} // namespace o3d + +#endif // O3D_CONVERTER_CROSS_EFFECT_STUB_H_ diff --git a/o3d/converter/cross/param_cache_stub.h b/o3d/converter/cross/param_cache_stub.h new file mode 100644 index 0000000..5ae89ee --- /dev/null +++ b/o3d/converter/cross/param_cache_stub.h @@ -0,0 +1,69 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the declaration of the ParamCacheStub class. + +#ifndef O3D_CONVERTER_CROSS_PARAM_CACHE_STUB_H_ +#define O3D_CONVERTER_CROSS_PARAM_CACHE_STUB_H_ + +#include "core/cross/param_cache.h" + +namespace o3d { + +class Effect; +class DrawElement; +class Element; +class Material; +class ParamObject; + +class ParamCacheStub : public ParamCache { + public: + ParamCacheStub() : ParamCache() {} + + // Overridden from ParamCache. + virtual void UpdateCache(Effect* effect, + DrawElement* draw_element, + Element* element, + Material* material, + ParamObject* override) {} + + protected: + // Overridden from ParamCache + // Validates platform specific information about the effect. + virtual bool ValidateEffect(Effect* effect) { return true; } + + private: + DISALLOW_COPY_AND_ASSIGN(ParamCacheStub); +}; +} // o3d + +#endif // O3D_CONVERTER_CROSS_PARAM_CACHE_STUB_H_ diff --git a/o3d/converter/cross/primitive_stub.h b/o3d/converter/cross/primitive_stub.h new file mode 100644 index 0000000..81b4808 --- /dev/null +++ b/o3d/converter/cross/primitive_stub.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the declaration of the PrimitiveStub class. + +#ifndef O3D_CONVERTER_CROSS_PRIMITIVE_STUB_H_ +#define O3D_CONVERTER_CROSS_PRIMITIVE_STUB_H_ + +#include "core/cross/primitive.h" + +namespace o3d { + +class DrawElement; +class Material; +class ParamCache; +class ParamObject; +class Renderer; +class ServiceLocator; + +// PrimitiveStub is the Stub implementation of the Primitive. It provides the +// necessary interfaces for setting the geometry streams on the Primitive. +class PrimitiveStub : public Primitive { + public: + explicit PrimitiveStub(ServiceLocator* service_locator) + : Primitive(service_locator) {} + virtual ~PrimitiveStub() {} + + // Overridden from Element + // Renders this Element using the parameters from override first, followed by + // the draw_element, followed by params on this Primitive and material. + virtual void Render(Renderer* renderer, + DrawElement* draw_element, + Material* material, + ParamObject* override, + ParamCache* param_cache) {} + + private: + DISALLOW_COPY_AND_ASSIGN(PrimitiveStub); +}; +} // o3d + +#endif // O3D_CONVERTER_CROSS_PRIMITIVE_STUB_H_ diff --git a/o3d/converter/cross/render_surface_stub.h b/o3d/converter/cross/render_surface_stub.h new file mode 100644 index 0000000..4e68677 --- /dev/null +++ b/o3d/converter/cross/render_surface_stub.h @@ -0,0 +1,75 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the declarations for RenderSurfaceGL and +// RenderDepthStencilSurfaceGL. + +#ifndef O3D_CONVERTER_CROSS_RENDER_SURFACE_STUB_H_ +#define O3D_CONVERTER_CROSS_RENDER_SURFACE_STUB_H_ + +#include "core/cross/render_surface.h" +#include "core/cross/texture.h" + +namespace o3d { + +class RenderSurfaceStub : public RenderSurface { + public: + typedef SmartPointer<RenderSurfaceStub> Ref; + + // Constructs a RenderSurfaceStub instance. + // Parameters: + // service_locator: Service locator for the instance. + RenderSurfaceStub(ServiceLocator *service_locator, + int width, + int height) + : RenderSurface(service_locator, width, height, NULL) {} + virtual ~RenderSurfaceStub() {} + private: + DISALLOW_COPY_AND_ASSIGN(RenderSurfaceStub); +}; + +class RenderDepthStencilSurfaceStub : public RenderDepthStencilSurface { + public: + typedef SmartPointer<RenderDepthStencilSurfaceStub> Ref; + + RenderDepthStencilSurfaceStub(ServiceLocator *service_locator, + int width, + int height) + : RenderDepthStencilSurface(service_locator, width, height) {} + virtual ~RenderDepthStencilSurfaceStub() {} + private: + DISALLOW_COPY_AND_ASSIGN(RenderDepthStencilSurfaceStub); +}; + +} // namespace o3d + +#endif // O3D_CONVERTER_CROSS_RENDER_SURFACE_STUB_H_ diff --git a/o3d/converter/cross/renderer_stub.cc b/o3d/converter/cross/renderer_stub.cc new file mode 100644 index 0000000..c53d2d5 --- /dev/null +++ b/o3d/converter/cross/renderer_stub.cc @@ -0,0 +1,223 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the definition of abstract functions in the +// cross platform API so that we can use it for serialization of the +// scene graph on all systems without needing graphics. + +#include "converter/cross/renderer_stub.h" +#include "core/cross/object_manager.h" +#include "core/cross/service_locator.h" +#include "converter/cross/buffer_stub.h" +#include "converter/cross/draw_element_stub.h" +#include "converter/cross/effect_stub.h" +#include "converter/cross/param_cache_stub.h" +#include "converter/cross/primitive_stub.h" +#include "converter/cross/render_surface_stub.h" +#include "converter/cross/sampler_stub.h" +#include "converter/cross/stream_bank_stub.h" +#include "converter/cross/texture_stub.h" + +namespace o3d { + +Renderer* RendererStub::CreateDefault(ServiceLocator* service_locator) { + return new RendererStub(service_locator); +} + +RendererStub::RendererStub(ServiceLocator* service_locator) + : Renderer(service_locator) { +} + +Renderer::InitStatus RendererStub::InitPlatformSpecific( + const DisplayWindow&, bool) { + DCHECK(false); + return SUCCESS; +} + +void RendererStub::InitCommon() { +} + +void RendererStub::UninitCommon() { +} + +void RendererStub::Destroy(void) { + DCHECK(false); +} + +bool RendererStub::BeginDraw(void) { + DCHECK(false); + return true; +} + +void RendererStub::EndDraw(void) { + DCHECK(false); +} + +bool RendererStub::StartRendering(void) { + DCHECK(false); + return true; +} + +void RendererStub::FinishRendering(void) { + DCHECK(false); +} + +void RendererStub::Resize(int, int) { + DCHECK(false); +} + +void RendererStub::Clear(const Float4 &, bool, float, bool, int, bool) { + DCHECK(false); +} + +void RendererStub::RenderElement(Element *, + DrawElement *, + Material *, + ParamObject *, + ParamCache *) { + DCHECK(false); +} + +void RendererStub::SetRenderSurfacesPlatformSpecific( + RenderSurface* surface, + RenderDepthStencilSurface* surface_depth) { + DCHECK(false); +} + +void RendererStub::SetBackBufferPlatformSpecific() { + DCHECK(false); +} + +Primitive::Ref RendererStub::CreatePrimitive(void) { + return Primitive::Ref(new PrimitiveStub(service_locator())); +} + +DrawElement::Ref RendererStub::CreateDrawElement(void) { + return DrawElement::Ref(new DrawElementStub(service_locator())); +} + +VertexBuffer::Ref RendererStub::CreateVertexBuffer(void) { + return VertexBuffer::Ref(new VertexBufferStub(service_locator())); +} + +IndexBuffer::Ref RendererStub::CreateIndexBuffer(void) { + return IndexBuffer::Ref(new IndexBufferStub(service_locator())); +} + +Effect::Ref RendererStub::CreateEffect(void) { + return Effect::Ref(new EffectStub(service_locator())); +} + +Sampler::Ref RendererStub::CreateSampler(void) { + return Sampler::Ref(new SamplerStub(service_locator())); +} + +Texture::Ref RendererStub::CreatePlatformSpecificTextureFromBitmap( + Bitmap *bitmap) { + if (bitmap->is_cubemap()) { + return Texture::Ref(new TextureCUBEStub(service_locator(), + bitmap->width(), + bitmap->format(), + bitmap->num_mipmaps(), + false)); + } else { + return Texture::Ref(new Texture2DStub(service_locator(), + bitmap->width(), + bitmap->height(), + bitmap->format(), + bitmap->num_mipmaps(), + false)); + } +} + +Texture2D::Ref RendererStub::CreatePlatformSpecificTexture2D( + int width, + int height, + Texture::Format format, + int levels, + bool enable_render_surfaces) { + return Texture2D::Ref(new Texture2DStub(service_locator(), + width, + height, + format, + levels, + enable_render_surfaces)); +} + +TextureCUBE::Ref RendererStub::CreatePlatformSpecificTextureCUBE( + int edge_length, + Texture::Format format, + int levels, + bool enable_render_surfaces) { + return TextureCUBE::Ref(new TextureCUBEStub(service_locator(), + edge_length, + format, + levels, + enable_render_surfaces)); +} + +RenderDepthStencilSurface::Ref RendererStub::CreateDepthStencilSurface( + int width, + int height) { + return RenderDepthStencilSurface::Ref( + new RenderDepthStencilSurfaceStub(service_locator(), width, height)); +} + +StreamBank::Ref RendererStub::CreateStreamBank() { + return StreamBank::Ref(new StreamBankStub(service_locator())); +} + +bool RendererStub::SaveScreen(const String &) { + DCHECK(false); + return true; +} + +ParamCache *RendererStub::CreatePlatformSpecificParamCache(void) { + return new ParamCacheStub; +} + +void RendererStub::SetViewportInPixels(int, int, int, int, float, float) { + DCHECK(false); +} + +const int* RendererStub::GetRGBAUByteNSwizzleTable() { + static int swizzle_table[] = { 0, 1, 2, 3, }; + return swizzle_table; +} + +// This is a factory function for creating Renderer objects. Since +// we're implementing a stub renderer, we only ever return a stub renderer. +Renderer* Renderer::CreateDefaultRenderer(ServiceLocator* service_locator) { + return RendererStub::CreateDefault(service_locator); +} + +} // namespace o3d diff --git a/o3d/converter/cross/renderer_stub.h b/o3d/converter/cross/renderer_stub.h new file mode 100644 index 0000000..afd5d41 --- /dev/null +++ b/o3d/converter/cross/renderer_stub.h @@ -0,0 +1,126 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the declaration of functions needed to +// instantiate a renderer from the core cross-platform API so that we +// can use it for serialization of the scene graph on all systems +// without needing graphics. + +#ifndef O3D_CONVERTER_CROSS_RENDERER_STUB_H__ +#define O3D_CONVERTER_CROSS_RENDERER_STUB_H__ + +#include "core/cross/renderer.h" + +namespace o3d { + +// Please see core/cross/renderer.h for documentation of these +// functions. With the exception of the "Create..." methods, these +// are mostly just stubbed out here, and don't do anything. + +class RendererStub : public Renderer { + public: + static Renderer* CreateDefault(ServiceLocator* service_locator); + virtual InitStatus InitPlatformSpecific(const DisplayWindow& display, + bool off_screen); + virtual void InitCommon(); + virtual void UninitCommon(); + virtual void Destroy(); + virtual bool BeginDraw(); + virtual void EndDraw(); + virtual bool StartRendering(); + virtual void FinishRendering(); + virtual void Resize(int width, int height); + virtual void Clear(const Float4 &color, + bool color_flag, + float depth, + bool depth_flag, + int stencil, + bool stencil_flag); + virtual void RenderElement(Element* element, + DrawElement* draw_element, + Material* material, + ParamObject* override, + ParamCache* param_cache); + virtual Primitive::Ref CreatePrimitive(); + virtual DrawElement::Ref CreateDrawElement(); + virtual VertexBuffer::Ref CreateVertexBuffer(); + virtual IndexBuffer::Ref CreateIndexBuffer(); + virtual Effect::Ref CreateEffect(); + virtual Sampler::Ref CreateSampler(); + virtual RenderDepthStencilSurface::Ref CreateDepthStencilSurface(int width, + int height); + virtual StreamBank::Ref CreateStreamBank(); + virtual bool SaveScreen(const String& file_name); + ParamCache *CreatePlatformSpecificParamCache(); + virtual void SetViewportInPixels(int left, + int top, + int width, + int height, + float min_z, + float max_z); + + // Overridden from Renderer. + virtual const int* GetRGBAUByteNSwizzleTable(); + + protected: + explicit RendererStub(ServiceLocator* service_locator); + + // Overridden from Renderer. + virtual Texture::Ref CreatePlatformSpecificTextureFromBitmap(Bitmap* bitmap); + + // Overridden from Renderer. + virtual void SetBackBufferPlatformSpecific(); + + // Overridden from Renderer. + virtual void SetRenderSurfacesPlatformSpecific( + RenderSurface* surface, + RenderDepthStencilSurface* depth_surface); + + // Overridden from Renderer. + virtual Texture2D::Ref CreatePlatformSpecificTexture2D( + int width, + int height, + Texture::Format format, + int levels, + bool enable_render_surfaces); + + // Overridden from Renderer. + virtual TextureCUBE::Ref CreatePlatformSpecificTextureCUBE( + int edge_length, + Texture::Format format, + int levels, + bool enable_render_surfaces); +}; + +} // namespace o3d + +#endif // O3D_CONVERTER_CROSS_RENDERER_STUB_H__ diff --git a/o3d/converter/cross/sampler_stub.h b/o3d/converter/cross/sampler_stub.h new file mode 100644 index 0000000..61da44b --- /dev/null +++ b/o3d/converter/cross/sampler_stub.h @@ -0,0 +1,53 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the class declaration for SamplerStub. + +#ifndef O3D_CONVERTER_CROSS_SAMPLER_STUB_H_ +#define O3D_CONVERTER_CROSS_SAMPLER_STUB_H_ + +#include "core/cross/sampler.h" + +namespace o3d { + +// SamplerStub is an implementation of the Sampler object for the converter. +class SamplerStub : public Sampler { + public: + explicit SamplerStub(ServiceLocator* service_locator) + : Sampler(service_locator) {} + virtual ~SamplerStub() {} + private: + DISALLOW_COPY_AND_ASSIGN(SamplerStub); +}; +} // namespace o3d + +#endif // O3D_CONVERTER_CROSS_SAMPLER_STUB_H_ diff --git a/o3d/converter/cross/stream_bank_stub.h b/o3d/converter/cross/stream_bank_stub.h new file mode 100644 index 0000000..b137519 --- /dev/null +++ b/o3d/converter/cross/stream_bank_stub.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the declaration of the StreamBankGL class. + +#ifndef O3D_CONVERTER_CROSS_STREAM_BANK_STUB_H_ +#define O3D_CONVERTER_CROSS_STREAM_BANK_STUB_H_ + +#include "core/cross/stream_bank.h" + +namespace o3d { + +// StreamBankStub is the Stub implementation of the StreamBank. +class StreamBankStub : public StreamBank { + public: + explicit StreamBankStub(ServiceLocator* service_locator) + : StreamBank(service_locator) {} + virtual ~StreamBankStub() {} +}; +} // o3d + +#endif // O3D_CONVERTER_CROSS_STREAM_BANK_STUB_H_ diff --git a/o3d/converter/cross/texture_stub.cc b/o3d/converter/cross/texture_stub.cc new file mode 100644 index 0000000..4c91fb5 --- /dev/null +++ b/o3d/converter/cross/texture_stub.cc @@ -0,0 +1,51 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +#include "converter/cross/texture_stub.h" + +namespace o3d { + +namespace { + +Texture::RGBASwizzleIndices g_stub_abgr32f_swizzle_indices = {0, 1, 2, 3}; + +} // anonymous namespace. + +const Texture::RGBASwizzleIndices& Texture2DStub::GetABGR32FSwizzleIndices() { + return g_stub_abgr32f_swizzle_indices; +} + +const Texture::RGBASwizzleIndices& TextureCUBEStub::GetABGR32FSwizzleIndices() { + return g_stub_abgr32f_swizzle_indices; +} + +} // namespace o3d diff --git a/o3d/converter/cross/texture_stub.h b/o3d/converter/cross/texture_stub.h new file mode 100644 index 0000000..78e971c --- /dev/null +++ b/o3d/converter/cross/texture_stub.h @@ -0,0 +1,152 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the declarations for Texture2DStub and TextureCUBEStub. + +#ifndef O3D_CONVERTER_CROSS_TEXTURE_STUB_H__ +#define O3D_CONVERTER_CROSS_TEXTURE_STUB_H__ + +#include "core/cross/bitmap.h" +#include "core/cross/texture.h" +#include "core/cross/types.h" + +namespace o3d { + +// Texture2DStub implements the stub Texture2D interface for the converter. +class Texture2DStub : public Texture2D { + public: + typedef SmartPointer<Texture2DStub> Ref; + + Texture2DStub(ServiceLocator* service_locator, + int width, + int height, + Texture::Format format, + int levels, + bool enable_render_surfaces) + : Texture2D(service_locator, + width, + height, + format, + levels, + false, + false, + enable_render_surfaces) {} + virtual ~Texture2DStub() {} + + // Locks the image buffer of a given mipmap level for writing from main + // memory. + virtual bool Lock(int level, void** texture_data) { return true; } + + // Unlocks this texture and returns it to Stub control. + virtual bool Unlock(int level) { return true; } + + // Returns a RenderSurface object associated with a mip_level of a texture. + // Parameters: + // mip_level: [in] The mip-level of the surface to be returned. + // pack: [in] The pack in which the surface will reside. + // Returns: + // Reference to the RenderSurface object. + virtual RenderSurface::Ref GetRenderSurface(int mip_level, Pack *pack) { + return RenderSurface::Ref(NULL); + } + + // Returns the implementation-specific texture handle for this texture. + void* GetTextureHandle() const { + return NULL; + } + + // Gets a RGBASwizzleIndices that contains a mapping from + // RGBA to the internal format used by the rendering API. + virtual const RGBASwizzleIndices& GetABGR32FSwizzleIndices(); + + private: + DISALLOW_COPY_AND_ASSIGN(Texture2DStub); +}; + + +// TextureCUBEStub implements the TextureCUBE interface for the converter stub. +class TextureCUBEStub : public TextureCUBE { + public: + typedef SmartPointer<TextureCUBEStub> Ref; + TextureCUBEStub(ServiceLocator* service_locator, + int edge_length, + Texture::Format format, + int levels, + bool enable_render_surfaces) + : TextureCUBE(service_locator, + edge_length, + format, + levels, + false, + false, + enable_render_surfaces) {} + virtual ~TextureCUBEStub() {} + + // Locks the image buffer of a given face and mipmap level for loading + // from main memory. + virtual bool Lock(CubeFace face, int level, void** texture_data) { + return true; + } + + // Unlocks the image buffer of a given face and mipmap level. + virtual bool Unlock(CubeFace face, int level) { return true; } + + // Returns a RenderSurface object associated with a given cube face and + // mip_level of a texture. + // Parameters: + // face: [in] The cube face from which to extract the surface. + // mip_level: [in] The mip-level of the surface to be returned. + // pack: [in] The pack in which the surface will reside. + // Returns: + // Reference to the RenderSurface object. + virtual RenderSurface::Ref GetRenderSurface(CubeFace face, + int level, + Pack* pack) { + return RenderSurface::Ref(NULL); + } + + // Returns the implementation-specific texture handle for this texture. + void* GetTextureHandle() const { + return NULL; + } + + // Gets a RGBASwizzleIndices that contains a mapping from + // RGBA to the internal format used by the rendering API. + virtual const RGBASwizzleIndices& GetABGR32FSwizzleIndices(); + + private: + DISALLOW_COPY_AND_ASSIGN(TextureCUBEStub); +}; + +} // namespace o3d + +#endif // O3D_CONVERTER_CROSS_TEXTURE_STUB_H__ diff --git a/o3d/converter/cross/verifier_main.cc b/o3d/converter/cross/verifier_main.cc new file mode 100644 index 0000000..4ffde5b --- /dev/null +++ b/o3d/converter/cross/verifier_main.cc @@ -0,0 +1,106 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the main routine for the converter that writes +// out a scene graph as a JSON file. + +#include <string> +#include <iostream> +#include <vector> + +#include "base/at_exit.h" +#include "base/file_path.h" +#include "base/command_line.h" +#include "converter/cross/converter.h" +#include "utils/cross/file_path_utils.h" + +using std::string; +using std::wstring; + +#if defined(OS_WIN) +int wmain(int argc, wchar_t **argv) { + // On Windows, CommandLine::Init ignores its arguments and uses + // GetCommandLineW. + CommandLine::Init(0, NULL); +#endif +#if defined(OS_LINUX) +int main(int argc, char **argv) { + CommandLine::Init(argc, argv); +#endif +#if defined(OS_MACOSX) +// The "real" main on Mac is in mac/converter_main.mm, so we can get +// memory pool initialization for Cocoa. +int CrossMain(int argc, char**argv) { + CommandLine::Init(argc, argv); +#endif + // Create an at_exit_manager so that base singletons will get + // deleted properly. + base::AtExitManager at_exit_manager; + const CommandLine* command_line = CommandLine::ForCurrentProcess(); + + FilePath in_filename, out_filename; + + std::vector<std::wstring> values = command_line->GetLooseValues(); + if (values.size() == 1) { + in_filename = o3d::WideToFilePath(values[0]); + } else if (values.size()== 2) { + in_filename = o3d::WideToFilePath(values[0]); + out_filename = o3d::WideToFilePath(values[1]); + } else { + std::cerr << "Usage: " << FilePath(argv[0]).BaseName().value() + << " [--no-condition] <infile.fx> [<outfile.fx>]\n"; + return EXIT_FAILURE; + } + + o3d::converter::Options options; + options.condition = !command_line->HasSwitch(L"no-condition"); + + if (!options.condition && !out_filename.empty()) { + std::cerr << "Warning: Ignoring output filename because conditioning " + << "has been turned off.\n"; + out_filename = FilePath(); + } + + o3d::String errors; + bool result = o3d::converter::Verify(in_filename, out_filename, options, + &errors); + if (result) { + std::cerr << "Shader in '" << o3d::FilePathToUTF8(in_filename).c_str() + << "' has been validated." << std::endl; + return EXIT_SUCCESS; + } else { + std::cerr << errors.c_str() << std::endl; + std::cerr << "Shader in '" << o3d::FilePathToUTF8(in_filename).c_str() + << "' FAILED to be validated." << std::endl; + return EXIT_FAILURE; + } +} diff --git a/o3d/converter/mac/converter_main.mm b/o3d/converter/mac/converter_main.mm new file mode 100644 index 0000000..4e9a4af --- /dev/null +++ b/o3d/converter/mac/converter_main.mm @@ -0,0 +1,49 @@ +/* + * Copyright 2009, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +// This file contains the main routine for the converter that writes +// out a scene graph as a JSON file. Really, just a shell for the +// common main routine in cross so we can get memory pool +// initialization for Cocoa. + +#import <Cocoa/Cocoa.h> + +// Defined in converter/cross/converter_main.cc +extern int CrossMain(int argc, char** argv); + +int main(int argc, char** argv) { + // Make a pool to use for any Cocoa objects in the app. + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + int result = CrossMain(argc, argv); + [pool release]; + return result; +} |